25. K 个一组翻转链表

Posted 2020-12-01 朴素贝叶斯

题目描述:

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明 :

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

1 /**
2  * Definition for singly-linked list.
3  * struct ListNode {
4  *     int val;
5  *     ListNode *next;
6  *     ListNode(int x) : val(x), next(NULL) {}
7  * };
8  */

解法1：递归方法

 1 class Solution {
 2 public:
 3     ListNode *reverseKGroup(ListNode *head, int k) {
 4 
 5         if(head==nullptr || head->next==nullptr || k<2)
 6             return head;
 7         ListNode *p = head;        
 8         int cnt = 0;
 9         while(p!=nullptr)
10         {
11             cnt++;
12             if(cnt == k)
13                 break;
14             p = p->next;
15         }
16         if(p == nullptr)
17             return head;
18         ListNode *next = p->next;
19         p->next = nullptr;
20         ListNode *ret = reverseList(head);
21         head->next = reverseKGroup(next,k);
22         return ret;        
23     }
24 
25     ListNode *reverseList(ListNode *head)
26     {
27         if(head==nullptr || head->next==nullptr)
28             return head;
29         ListNode *last = nullptr;
30         ListNode *cur = head;
31         while(cur!=nullptr)
32         {
33             ListNode * temp = cur->next;
34             cur->next = last;
35             last = cur;
36             cur = temp;
37         }
38         return last;
39     }
40 };

 解法2：直接做

 

 1 class Solution {
 2 public:
 3     ListNode *reverseKGroup(ListNode *head, int k) {
 4 
 5         if(head==nullptr || head->next==nullptr || k<2)
 6             return head;        
 7         ListNode dummy = ListNode(-1);
 8         ListNode *last = &dummy;
 9         ListNode *cur = head;
10         while(cur)
11         {
12             ListNode *p = cur;
13             int cnt = 0;
14             while(p!=nullptr)
15             {
16                 cnt++;
17                 if(cnt == k)
18                     break;
19                 p = p->next;
20             }
21             if(p == nullptr)
22             {
23                 last->next = cur;
24                 return dummy.next;
25             }
26             ListNode *next = p->next;
27             p->next = nullptr;
28             last->next = reverseList(cur);
29             last = cur;
30             cur = next;
31         }
32         return dummy.next;        
33     }
34 
35     ListNode *reverseList(ListNode *head)
36     {
37         if(head==nullptr || head->next==nullptr)
38             return head;
39         ListNode *last = nullptr;
40         ListNode *cur = head;
41         while(cur!=nullptr)
42         {
43             ListNode * temp = cur->next;
44             cur->next = last;
45             last = cur;
46             cur = temp;
47         }
48         return last;
49 
50     }
51 };