用于反转双向链表的Java程序

给定一个双向链表，任务是反转给定的双向链表。

例如，请参见下图。

(a) Original Doubly Linked List  

(b) Reversed Doubly Linked List  

这是一个反转双向链表的简单方法。我们需要做的就是交换所有节点的 prev 和 next 指针，更改 head（或 start）的 prev 并最终更改 head 指针。

Java

// Java program to reverse a doubly 
// linked list
class LinkedList 
{
    static Node head;
    static class Node 
    {
        int data;
        Node next, prev;
        Node(int d)
        {
            data = d;
            next = prev = null;
        }
    }
  
    /* Function to reverse a Doubly 
       Linked List */
    void reverse()
    {
        Node temp = null;
        Node current = head;
  
        /* Swap next and prev for all nodes 
           of doubly linked list */
        while (current != null) 
        {
            temp = current.prev;
            current.prev = current.next;
            current.next = temp;
            current = current.prev;
        }
  
        /* Before changing head, check for the 
           cases like empty list and list with 
           only one node */
        if (temp != null) 
        {
            head = temp.prev;
        }
    }
  
    // UTILITY FUNCTIONS 
    /* Function to insert a node at the 
       beginning of the Doubly Linked List */
    void push(int new_data)
    {
        // Allocate node 
        Node new_node = new Node(new_data);
  
        /* Since we are adding at the beginning,
           prev is always NULL */
        new_node.prev = null;
  
        // Link the old list off the new node 
        new_node.next = head;
  
        /* Change prev of head node to 
           new node */
        if (head != null) {
            head.prev = new_node;
        }
  
        /* Move the head to point to the 
           new node */
        head = new_node;
    }
  
    /* Function to print nodes in a given 
       doubly linked list. This function is 
       same as printList() of singly linked
       list */
    void printList(Node node)
    {
        while (node != null) 
        {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }
  
    public static void main(String[] args)
    {
        LinkedList list = new LinkedList();
  
        /* Let us create a sorted linked list 
           to test the functions Created linked 
           list will be 10->8->4->2 */
        list.push(2);
        list.push(4);
        list.push(8);
        list.push(10);
  
        System.out.println(
        "Original linked list ");
        list.printList(head);
  
        list.reverse();
        System.out.println("");
        System.out.println(
        "The reversed Linked List is ");
        list.printList(head);
    }
}
// This code is contributed by Mayank Jaiswal

输出：

Original linked list 
10 8 4 2 
The reversed Linked List is 
2 4 8 10

方法二：

同样的问题也可以通过使用 Stacks 来完成。

脚步：

1. 继续将节点的数据推入堆栈。 -> O(n)
2. 不断弹出元素并更新双向链表

Java

// Java program to reverse a doubly 
// linked list
import java.util.*;
class LinkedList 
{
    static Node head;
  
    static class Node 
    {
        int data;
        Node next, prev;
  
        Node(int d)
        {
            data = d;
            next = prev = null;
        }
    }
  
    /* Function to reverse a Doubly Linked 
       List using Stacks */
    void reverse()
    {
        Stack stack = new Stack<>();
        Node temp = head;
        while (temp != null) 
        {
            stack.push(temp.data);
            temp = temp.next;
        }
        // Added all the elements sequence 
        // wise in the stack
        temp = head;
        while (temp != null) 
        {
            temp.data = stack.pop();
            temp = temp.next;
        }
  
        // Popped all the elements and the 
        // added in the linked list,
        // which are in the reversed order.
    }
  
    // UTILITY FUNCTIONS 
    /* Function to insert a node at the 
       beginning of the Doubly Linked List */
    void push(int new_data)
    {
        // Allocate node 
        Node new_node = new Node(new_data);
  
        /* Since we are adding at the beginning,
           prev is always NULL */
        new_node.prev = null;
  
        /* Link the old list off the new node */
        new_node.next = head;
  
        /* Change prev of head node to 
           new node */
        if (head != null) 
        {
            head.prev = new_node;
        }
  
        /* move the head to point to the new node */
        head = new_node;
    }
  
    /* Function to print nodes in a given doubly linked list
     This function is same as printList() of singly linked
     list */
    void printList(Node node)
    {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        LinkedList list = new LinkedList();
  
        /* Let us create a sorted linked list to test the
         functions Created linked list will be 10->8->4->2
       */
        list.push(2);
        list.push(4);
        list.push(8);
        list.push(10);
  
        System.out.println(
        "Original linked list ");
        list.printList(head);
  
        list.reverse();
        System.out.println("");
        System.out.println(
        "The reversed Linked List is ");
        list.printList(head);
    }
}
// This code is contributed by Rashita Mehta

输出：

Original linked list 
10 8 4 2 
The reversed Linked List is 
2 4 8 10

时间复杂度： O(N)
辅助空间： O(N)

在这个方法中，我们遍历链表一次并将元素添加到堆栈中，然后再次遍历整体以更新所有元素。整体需要2n时间，也就是O(n)的时间复杂度。

有关详细信息，请参阅有关反向双向链表的完整文章！