用于反转双向链表的 C++ 程序

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

例如，请参见下图。

(a) Original Doubly Linked List  

(b) Reversed Doubly Linked List  

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

C++

/* C++ program to reverse a doubly 
   linked list */
#include 
using namespace std;
  
// A node of the doubly linked list 
class Node 
{ 
    public:
    int data; 
    Node *next; 
    Node *prev; 
}; 
  
/* Function to reverse a Doubly 
   Linked List */
void reverse(Node **head_ref) 
{ 
    Node *temp = NULL; 
    Node *current = *head_ref; 
      
    /* 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 the head, check for 
       the cases like empty list and list 
       with only one node */
    if(temp != NULL ) 
        *head_ref = temp->prev; 
} 
  
// UTILITY FUNCTIONS 
/* Function to insert a node at the
   beginning of the Doubly Linked List */
void push(Node** head_ref, int new_data) 
{ 
    // Allocate node 
    Node* new_node = new Node();
  
    // Put in the data
    new_node->data = 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_ref);     
  
    /* Change prev of head node to 
       new node */
    if((*head_ref) != NULL) 
    (*head_ref)->prev = new_node ; 
  
    /* Move the head to point to the 
       new node */
    (*head_ref) = 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) 
    { 
        cout << node->data << " "; 
        node = node->next; 
    } 
} 
  
// Driver code 
int main() 
{ 
    // Start with the empty list 
    Node* head = NULL; 
      
    /* Let us create a sorted linked list 
       to test the functions. Created linked 
       list will be 10->8->4->2 */
    push(&head, 2); 
    push(&head, 4); 
    push(&head, 8); 
    push(&head, 10); 
      
    cout << 
    "Original Linked list" << endl; 
    printList(head); 
      
    // Reverse doubly linked list 
    reverse(&head); 
      
    cout << 
    "Reversed Linked list" << endl; 
    printList(head);         
      
    return 0;
} 
// This code is contributed by rathbhupendra

输出：

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

方法二：

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

脚步：

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

C++

// C++ program to reverse a doubly linked list
#include 
using namespace std;
struct LinkedList 
{
    struct Node 
    {
        int data;
        Node *next, *prev;
        Node(int d)
        {
            data = d;
            next = prev = NULL;
        }
    };
    Node* head = NULL;
  
    /* Function to reverse a Doubly Linked 
       List using Stacks */
    void reverse()
    {
        stack st;
        Node* temp = head;
        while (temp != NULL) 
        {
            st.push(temp->data);
            temp = temp->next;
        }
  
        // Added all the elements sequence 
        // wise in the set
        temp = head;
        while (temp != NULL) 
        {
            temp->data = st.top();
            st.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)
        {
            cout << node->data << " ";
            node = node->next;
        }
    }
};
  
// Driver Code
int main()
{
    LinkedList list;
  
    /* 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);
    cout << 
    "Original linked list " << endl;
    list.printList(list.head);
    list.reverse();
    cout << endl;
    cout << 
    "The reversed Linked List is " << endl;
    list.printList(list.head);
}
// This code is contributed by Pratham76

输出

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

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

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

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