Question

我正试图扭转循环双向链表，如下所示：

这是我的Node类：

       private class Node<T>
   {
       public T Data { get; set; }
       public Node<T> PreviousNode { get; set; }
       public Node<T> NextNode { get; set; }

       public Node(object data, Node<T> next, Node<T> previous)
       {
           Data = (T) data;
           PreviousNode = previous;
           NextNode = next;
       }
   }

这是我的链接列表类的一部分，这里是我的反向功能存储：

 public class DoublyLinkedList<T> :IList<T>
{
    private Node<T> headerNode;
 public DoublyLinkedList()
{
        headerNode = new Node<T>(null, null, null);

        headerNode.NextNode     = headerNode;
        headerNode.PreviousNode = headerNode;
        Count = 0;
}

   public void Insert(int index, T item)
   {
        Node<T> node;

        if (index == Count)
            node = new Node<T>(item, headerNode, headerNode.PreviousNode);                                                                   
        else
        {
            Node<T> tmp = FindNodeAt(index); 

            node = new Node<T>(item, tmp, tmp.PreviousNode);
        }

        node.PreviousNode.NextNode = node; 
        node.NextNode.PreviousNode = node; 

        Count++;

    }
 public void Reverse()
    {
       Node<T> temp;
       for (Node<T> node = headerNode.NextNode; node != headerNode; node = node.NextNode)
       {

       }
    }

我完全坚持使用这个Reverse（）函数。有什么帮助吗？

Answer 1

用于反转链表的算法非常简单：

列表是空的还是一个元素？如果是，那么它已经被逆转了。
否则，请创建一个新的空列表。在循环中，从旧列表中删除第一个项目并将其添加到新列表的开头。循环，直到第一个列表为空。

所以，把它分解成小块。你能写出以下方法：（1）检查列表是否为空（2）或者一个元素（3）从非空列表中删除第一项，（4）将项目放在列表的头部？如果你可以编写这四种方法，那么你可以将它们组合在一起写反向。

这就是你应该如何处理编程问题;编程就是将复杂的问题分解为更简单的问题，解决更简单的问题，并结合解决方案。

Answer 2

而不是反转列表，为什么不写一些方法来获得＆＃34; next＆＃34;和＆＃34;之前＆＃34;列表的节点取决于传入的方向标志：

public Node Next(Node current, bool forward)
{
    return forward ? current.NextNode : current.PreviousNode;
}

public Node Previous(Node current, bool forward)
{
    return forward ? current.PreviousNode : current.NextNode;
}

您可以使用值为bool forward＆amp;的枚举替换Forwards Backwards如果这样可以让代码更易于阅读。

Answer 3

如果要反转当前列表 - 那么这应该有效：

public void Reverse()
{
   if (count < 2)
    return;

   Node<T> node = headerNode;
   do
   {
        Node<T> temp = node.NextNode;
        node.NextNode = node.PreviousNode;
        node.PreviousNode = temp;
        node = temp;
   }
   while (temp != headerNode)
}

第一行检查空元素或单个元素列表。主循环遍历列表交换前一个＆amp;下一个节点，当它返回到标题节点时停止。结果是一个反向列表。

Answer 4

谢谢大家，我找到了解决方案。

 public void Reverse()
   {
       var currNode = headerNode;
       do
       {
           var temp = currNode.NextNode;
           currNode.NextNode = currNode.PreviousNode;
           currNode.PreviousNode = temp;
           currNode = currNode.PreviousNode;
       } 
       while (currNode != headerNode);
   }

c＃中的反向双向链表

4 个答案: