25. Reverse Nodes in k-Group

最新推荐文章于 2022-01-01 01:55:25 发布

unshaven111

最新推荐文章于 2022-01-01 01:55:25 发布

阅读量82

点赞数

分类专栏： ListNode 文章标签： 25

本文链接：https://blog.csdn.net/qq_38251888/article/details/84146509

版权

ListNode 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

Example:

Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

Note:

Only constant extra memory is allowed.
You may not alter the values in the list’s nodes, only nodes itself may be changed.

我的思路:
一个函数进行翻转操作,返回一个vector,第一个存入的ListNode的头指针和尾指针
listNode翻转的代码
1->2->3->4
两种思路
2->1->3->4==>3->2->1->4==>4->3->2->1；
拆分1->NULL 然后 2->1->NULL 然后3->2->1->NULL

自己代码

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode dummy(-1);
        ListNode* pre = &dummy;
        ListNode* cur = head;
        pre->next = head;
        vector<ListNode*> vec;
        while(cur){
            for(int i=0;i<k;i++){
                if(cur==NULL) return dummy.next;
                cur = cur->next;
            }
            vec = reverseListNode(pre->next,k);
            pre->next = vec[0];
            vec[1]->next = cur;
            pre = vec[1];
        }
        return dummy.next;
    }
    vector<ListNode*> reverseListNode(ListNode* head,int k){
        ListNode* prev = NULL;
        ListNode* cur = head;
        ListNode* tail = cur;
        while(cur && k>0){
            ListNode* next = cur->next;
            if(next==NULL){
                cur->next = prev;
                prev = cur;
                return vector<ListNode*>{prev,tail};
            }
            cur->next = prev;
            prev = cur;
            cur = next;
            k--;
        }
        return vector<ListNode*>{prev,tail};
    }
};

别人的思路
有几个tricks
1 先遍历整个listnode算出个数,然后每次减去k
2 翻转的时候用的翻转的第一种思路

-1 -> 1 -> 2 -> 3 -> 4 -> 5
 |    |    |    | 
pre  cur  nex  tmp

-1 -> 2 -> 1 -> 3 -> 4 -> 5
 |         |    |    | 
pre       cur  nex  tmp

-1 -> 3 -> 2 -> 1 -> 4 -> 5
 |              |    |    | 
pre            cur  nex  tmp
tmp其实不需要
class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        if(head==NULL||k==1) return head;
        int num=0;
        ListNode *preheader = new ListNode(-1);
        preheader->next = head;
        ListNode *cur = preheader, *nex, *pre = preheader;
        while(cur = cur->next) 
            num++;
        while(num>=k) {
            cur = pre->next;
            nex = cur->next;
            for(int i=1;i<k;++i) {
                cur->next=nex->next;
                nex->next=pre->next;
                pre->next=nex;
                nex=cur->next;
            }
            pre = cur;
            num-=k;
        }
        return preheader->next;
    }
};