206. Reverse Linked List + 92. Reverse Linked List II

▶ 关于单链表翻转的两个问题。

▶ 206. 翻转整个单链表。

● 自己的代码，9 ms，使用了递归。

 class Solution
 {
 public:
     ListNode* reverseList(ListNode* head)
     {
         if (head == nullptr)
             return nullptr;
         ListNode *p;
         for (p = head; p->next != nullptr; p = p->next);// 找到末元（翻转后的首元）
         reverseNode(head);
         return p;
     }
     inline void reverseNode(ListNode* p)// 翻转以 p 指向的结点为首元的单链表，并返回一个指向末元的指针（方便下一次挂上新的首元）
     {
         if (p == nullptr || p->next == nullptr)
             return;
         reverseNode(p->next);           // 翻转除首元意外的部分
         p->next->next = p;              // 把首元挂到最后
         p->next->next->next = nullptr;  // 去掉成环的部分
         return ;
     }
 };

● 大佬的代码，9 ms，逐格移动。

 class Solution
 {
 public:
     ListNode* reverseList(ListNode* head)
     {
         if (head == NULL || head->next == NULL)
             return head;
         ListNode *prev, *cur, *temp;
         for(prev = NULL, cur = head; cur != NULL;)
         {
             temp = cur->next;
             cur->next = prev;
             prev = cur;
             cur = temp;
         }
         return prev;
     }
 };

▶ 92. 要求翻转单链表中第 m 到第 n（两端包含，且 m 可以等于 n）之间的所有元。

● 自己的代码，4 ms，使用了第 206 题的结果。

 class Solution
 {
 public:
     ListNode* reverseBetween(ListNode* head, int m, int n)
     {
         if (head == nullptr)
             return head;
         ListNode newHead(-), *lp, *rp, *lpprev, *temp;
         newHead.next = head;
         int i, j;
         for (i = , lpprev = &newHead; i < m && lpprev != nullptr; i++, lpprev = lpprev->next);// 找到第 m-1 元和第 m 元
         if (lpprev == nullptr || (lp = lpprev->next) == nullptr)
             return head;
         for (j = i, rp = lp; j < n && rp != nullptr; j++, rp = rp->next);// 找到第 n 元
         if (rp == nullptr)
             return head;
         temp = rp->next;               // 尾部不翻转部分的首元
         rp->next = nullptr;            // 断开翻转部分的尾部链接
         lpprev->next = reverseList(lp);// 调用翻转函数
         lp->next = temp;               // 重新接上尾部
         return newHead.next;
     }
     ListNode* reverseList(ListNode* head)
     {
         if (head == nullptr)
             return nullptr;
         ListNode *p;
         for (p = head; p->next != nullptr; p = p->next);// 找到末元（翻转后的首元）
         reverseNode(head);
         return p;
     }
     inline void reverseNode(ListNode* p)// 翻转以 p 指向的结点为首元的单链表
     {
         if (p == nullptr || p->next == nullptr)
             return;
         reverseNode(p->next);           // 翻转除首元意外的部分
         p->next->next = p;              // 把首元挂到最后
         p->next->next->next = nullptr;  // 去掉成环的部分
         return;
     }
 };

● 大佬的代码，4 ms，也是使用逐格移动。

 class Solution
 {
 public:
     ListNode* reverseBetween(ListNode* head, int m, int n)
     {
         ListNode *first = new ListNode(), *t_head, *first_reverse, *node;
         first->next = head;
         t_head = first;
         for (int i = ; i<m - ; t_head = t_head->next, i++)
             first_reverse = t_head->next;
         node = t_head->next;
         for (int i = m; i <= n; i++)
         {
             ListNode * temp = node->next;
             node->next = t_head->next;
             t_head->next = node;
             node = temp;
         }
         first_reverse->next = node;
         return first->next;
     }
 };

▶ 一个副产品，交换单链表中的两个元素。我已开始把第 92 题理解错了，以为只是交换单链表中第 m 和第 n 个元素，所以写成了下面的东西。

 class Solution
 {
 public:
     ListNode* reverseBetween(ListNode* head, int m, int n)
     {
         if (head == nullptr)
             return head;
         ListNode newHead(-), *lp, *rp, *lpprev, *rpprev, *temp;
         newHead.next = head;
         int i, j;
         for (i = , lpprev = &newHead; i < m && lpprev != nullptr; i++, lpprev = lpprev->next);
         if (lpprev == nullptr || (lp = lpprev->next) == nullptr)
             return head;
         for (j = i, rpprev = lpprev; j < n && rpprev != nullptr; j++, rpprev = rpprev->next);
         if (rpprev == nullptr || (rp = rpprev->next) == nullptr)
             return head;
         lpprev->next = rp;
         rpprev->next = lp;
         swap(lp->next, rp->next);
         return newHead.next;
     }
 };