LeetCode #25 - Reverse Nodes in k-Group

最新推荐文章于 2022-07-31 18:18:38 发布

原创最新推荐文章于 2022-07-31 18:18:38 发布 · 411 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 同时被 2 个专栏收录

625 篇文章

订阅专栏

算法

41 篇文章

订阅专栏

本文介绍了一种算法，该算法将链表中的节点每K个一组进行翻转，并返回修改后的链表。通过递归方法实现，不改变节点值，仅调整节点位置，并且只使用常数级额外内存。

题目描述：

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.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For 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

这道题和之前的reverse linked list类似，但是这道题要难很多。这道题可以用递归来解，需要先在链表中确定一段长度为k的区间，将这一段链表翻转，然后用递归求出剩下的链表的翻转结果，将这两段连接起来，并保存好起始节点就可以了。不过需要注意的是当链表长度小于k，就应该直接返回头结点，可以定义一个函数求链表的长度来完成这个要求。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        int n=getLength(head);
        if (n<k) return head;
        ListNode* begin = head;
        ListNode* end = head;
        ListNode* result;
        while (end != NULL)
        {
            int count = k;
            while (end != NULL&&count>0)
            {
                end = end->next;
                count--;
            }
            if (count == 0)
            {
                result=reverseKNode(begin, end);
                begin->next = reverseKGroup(end, k);
                begin = end;
            }
            if(getLength(result)==n) return result;
        }
    }
    
    int getLength(ListNode* head)
    {
        if (head == NULL) return 0;
        int length = 0;
        while (head != NULL)
        {
            head = head->next;
            length++;
        }
        return length;
    }

    ListNode* reverseKNode(ListNode* &begin, ListNode* &end)
    {
        if (begin == end) return NULL;
        else if (begin->next == end) return begin;

        ListNode* result = new ListNode(0);
        result->next = begin;
        while (begin->next != end)
        {
            ListNode* p = begin->next;
            ListNode* q = begin->next->next;
            ListNode* temp = result->next;
            result->next = p;
            p->next = temp;
            begin->next = q;
        }
        return result->next;
    }
};