链表的部分逆转 Reverse Nodes in k-Group_链表逆转 k-优快云博客

本文介绍了一种解决LeetCode上K个一组翻转链表问题的方法，通过编写一个工具函数来实现链表节点的逆序，并在遍历整个链表的过程中多次调用该函数完成整体链表的翻转。

题目源自于leetcode。

题目：Given a linked list, reverse the nodes of a linked list k at a time and return its modified 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

思路：先写一个工具函数，能将k个链表逆序。然后对整个链表遍历时顺序调用多次该函数。

注意细节：

1、逆序部分的开头之前和结尾之后如何接上。

2、在某次逆序之后，如何找到下一次逆序时逆序部分的开头之前、结尾之后。

3、函数最后要返回新链表的首结点。

4、访问结构体的成员，指针可以使用->，对象则要用.

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *reverseKGroup(ListNode *head, int k) {
        if(k<=1)
            return head;
        
        struct ListNode H(0);
        H.next = head;

        ListNode *left, *right;
	    ListNode *tmp;
        left = &H;
	    right = head;
	    int num = 0;
        while(right != NULL)
        {
            num++;
            if(num == k)
            {
		        tmp = left->next;
                reverse(left, right->next, k);
		        num = 0;
		        left = tmp;
		        right = left->next;
            }
	        else
	        {
	    	    right = right->next;
	        }
        }
        return H.next;
    }
    
    //逆序段的前一个结点为pre，逆序段的后一个结点为end
    void reverse(ListNode *pre, ListNode *end, int n)
    {
        ListNode *oldl, *newl;
        oldl = pre->next->next;
        pre->next->next = end;
        for(int i=1;i<n;i++)
        {
            newl = oldl;
            oldl = oldl->next;
            newl->next = pre->next;
            pre->next = newl;
        }
    }
};