算法讲解-左神 【5】单双链表及其反转

/*
 * Definition for singly-linked list.
 */
 struct ListNode {
    int val;
    ListNode *next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}
 };

 //双链表节点
 struct DoubleListNode {
     int val;
     DoubleListNode* next;
     DoubleListNode* last;
     DoubleListNode() : val(0), next(nullptr), last(nullptr) {}
     DoubleListNode(int x) : val(x), next(nullptr), last(nullptr) {}
     DoubleListNode(int x, DoubleListNode* next, DoubleListNode* last) : val(x), next(next), last(last) {}
 };

 class Solution {
 public:
     //反转单链表
     ListNode* reverseList(ListNode* head) {
         ListNode* prev = nullptr;
         ListNode* curr = head;
         while (curr) {
             ListNode* next = curr->next;
             curr->next = prev;
             prev = curr;
             curr = next;
         }
         return prev;
     }

     //递归方式反转单链表
     ListNode* reverseList(ListNode* head) {
         // 链表为空时直接返回，链表不为空则到返回最后一个节点
         if (!head || !head->next) {
             return head;
         }
         // newHead先指向最后一个节点，注意此时参数是倒数第二个节点
         // 这一步很精妙，每一次newHead都是指向空指针（链表为空）或保留在原链表中的最后一个节点（链表不空），作用就是返回新的头结点
         ListNode* newHead = reverseList(head->next);
         // 最后一个节点指向倒数第二个节点
         head->next->next = head;
         // 倒数第二个节点的下一节点置空。此时倒数第三个节点仍指向倒数第二个节点，下一次递归中将倒数第二个节点下一节点指向倒数第三个节点，不断重复这一过程
         head->next = nullptr;
         return newHead;
     }

     //反转双链表
     DoubleListNode* reverseDoubleList(DoubleListNode* head) {
         DoubleListNode* prev = nullptr;
         DoubleListNode* curr = head;
         while (curr != nullptr) {
             DoubleListNode* next = curr->next;
             curr->next = prev;
             curr->last = next;
             prev = curr;
             curr = next;
         }
         return prev;
     }
 };

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台