自定义循环链表 c# 上的冒泡排序

Question

我创建了一个自定义循环链接列表，代码如下。 现在尝试实现冒泡排序（这是我告诉要做的，不是我所知道的最佳选择），我们如何以最佳可能的时间复杂度或最佳方法做

我的自定义循环链表我的疑问是最后一个节点，在冒泡排序的每个阶段都应该尝试最后排序，然后从第一个节点重新开始，如何处理最后一个节点作为它指向第一个节点的点

    public class CircularLinkedList<T> : ICollection<T>, IEnumerable<T>
    {

        Node<T> head = null;
        Node<T> tail = null;
        int count = 0;
        readonly IEqualityComparer<T> comparer;

        public int Count { get { return count; } }
        public bool IsReadOnly { get { return false; } }

        public void Add(T item)
        {
            this.AddLast(item);
        }
        public void AddLast(T item)
        {
            if (head == null)
                this.AddFirstItem(item);
            else
            {
                Node<T> newNode = new Node<T>(item);
                tail.Next = newNode;
                newNode.Next = head;
                newNode.Previous = tail;
                tail = newNode;
                head.Previous = tail;
            }
            ++count;
        }

        void AddFirstItem(T item)
        {
            head = new Node<T>(item);
            tail = head;
            head.Next = tail;
            head.Previous = tail;
        }
        public void Clear()
        {
            head = null;
            tail = null;
            count = 0;
        }
        public bool Contains(T item)
        {
            return Find(item) != null;
        }

        public Node<T> Find(T item)
        {
            Node<T> node = FindNode(head, item);
            return node;
        }

        Node<T> FindNode(Node<T> node, T valueToCompare)
        {
            Node<T> result = null;
            if (comparer.Equals(node.Value, valueToCompare))
                result = node;
            else if (result == null && node.Next != head)
                result = FindNode(node.Next, valueToCompare);
            return result;
        }


        public void CopyTo(T[] array, int arrayIndex)
        {
            if (array == null)
                throw new ArgumentNullException("array");
            if (arrayIndex < 0 || arrayIndex > array.Length)
                throw new ArgumentOutOfRangeException("arrayIndex");

            Node<T> node = this.head;
            do
            {
                array[arrayIndex++] = node.Value;
                node = node.Next;
            } while (node != head);
        }

        public IEnumerator<T> GetEnumerator()
        {
            Node<T> current = head;
            if (current != null)
            {
                do
                {
                    yield return current.Value;
                    current = current.Next;
                } while (current != head);
            }
        }
        public bool Remove(T item)
        {
            Node<T> nodeToRemove = this.Find(item);
            if (nodeToRemove != null)
                return this.RemoveNode(nodeToRemove);
            return false;
        }

        bool RemoveNode(Node<T> nodeToRemove)
        {
            Node<T> previous = nodeToRemove.Previous;
            previous.Next = nodeToRemove.Next;
            nodeToRemove.Next.Previous = nodeToRemove.Previous;

            // if this is head, we need to update the head reference
            if (head == nodeToRemove)
                head = nodeToRemove.Next;
            else if (tail == nodeToRemove)
                tail = tail.Previous;

            --count;
            return true;
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}

我的节点 class 具有三个属性

public T Value { get; private set; }
public Node<T> Next { get; set; }
public Node<T> Previous { get; set; }

Answer 1

首先，让我假设Node<T> object 具有（至少）2个标准属性： Value和Next ：

public class Node<T> {
  ...
  public T Value {get; set;}
  public Node<T> Next {get;} 
}

由于您有循环链表，

tail.Next == head

我们可以枚举除最后一项以外的所有项目

for (Node<T> node = head; !ReferenceEquals(node.Next, head); node = node.Next) {
  ...
}

仅供参考，如果我们有一个链表（非循环），循环将是（我们要做的就是将head更改为null ）：

for (Node<T> node = head; !ReferenceEquals(node.Next, null); node = node.Next) {
  ...
}

代码可以

public void BubbleSort(IComparer<T> comparer = null) {
  comparer ??= Comparer<T>.Default;

  if (comparer is null)
    throw new ArgumentNullException(nameof(comparer));

  if (head is null)
    return; // empty linked list

  bool agenda = true;

  while (agenda) {
    agenda = false;

    for (Node<T> node = head; !ReferenceEquals(node.Next, head); node = node.Next) 
      if (comparer.Compare(node.Value, node.Next.Value) > 0) {
        agenda = true;

        var help = node.Value; 
        node.Value = node.Next.Value;
        node.Next.Value = help;   
      } 
  } 
}