在C＃中反向双向链表

Question

I'am trying to reverse circular doubly linked list, which looks like this:

Here is my Node class:

       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;
       }
   }

And here is part of my Linked list class, here is my reverse funtion is stored:

 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)
       {

       }
    }

I completly stuck with this Reverse() function. Any help?

Answer 1

The algorithm for reversing a linked list is very simple:

• Is the list empty or one element? If yes, then it is already reversed.
• Otherwise, create a new empty list. In a loop, remove the first item from the old list and add it to the start of the new list. Loop until the first list is empty.

So, break it down into smaller pieces. Can you write methods that (1) check if a list is empty (2) or one element (3) remove the first item from a non-empty list, (4) put an item onto the head of a list ? If you can write those four methods then you can combine them together to write Reverse.

This is how you should be approaching your programming problems; programming is all about breaking complex problems down into simpler problems, solving the simpler problems, and combining the solutions.

Answer 2

Rather than reverse the list why not write a couple of methods that get the "next" and "previous" node of the list depending on a direction flag that's passed in:

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;
}

You could replace bool forward by an enum with values Forwards & Backwards if that'd make the code easier to read.

Answer 3

If you want to reverse the current list - then this should work :

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)
}

The first lines check for empty or single element list. The main loop iterates through the list swapping the previous & next nodes, stopping when it gets back to the header node. The result is a reversed list.

Answer 4

Thanks everybody, I have found the solution.

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