牛客刷题--链表局部反转

题目描述

将给出的链表中的节点每\ k k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是\ k k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。
要求空间复杂度 \ O(1) O(1)

例如：

给定的链表是1\to2\to3\to4\to51→2→3→4→5

对于 \ k = 2 k=2, 你应该返回 2\to 1\to 4\to 3\to 52→1→4→3→5

对于 \ k = 3 k=3, 你应该返回 3\to2 \to1 \to 4\to 53→2→1→4→5

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* reverseKGroup(ListNode* head, int k) {
        // write code here
        //思路是两个指针用来划分链表变成k段，然后每段内进行反转
        struct ListNode *p0 = NULL;//指向头节点 记录循环
        struct ListNode *p1 = head;//指向头节点 记录循环
        struct ListNode *p2 = head;//p2指向第二个指针
        struct ListNode *p3 = head;//p2指向每组的末尾节点
        struct ListNode *NewHead = NULL;//指向数组头节点
        struct ListNode *Re = NULL;//记录每段的前指针
        int flag = 0;
        if(head->next==NULL) return head;
        while(true)
        {
                for(int i = 0 ; i<k ;i++)
            {
                    if(i<k-1&&p3->next==NULL)
                    {
                        p0 = NewHead;
                        while(p0->next!=NULL)
                        {
                            p0 = p0->next;
                        }
                        p0->next = p1;
                        return NewHead;
                    }
                if(p3->next!=NULL)p3 = p3->next;//将指向最后的节点
            }
            while(p2->next!=p3)
            {
                p2 = p2->next;
            }
            p2->next = NULL;//完成第一段切割
            Re = Group(p1);//接收第一段 Re作为头节点
            if(NewHead == NULL){
                NewHead = Re;
            }
            else
            {
                p0= NewHead;
                while(p0->next!=NULL)
                {
                    p0= p0->next;
                }
                p0->next = Re;
            }
            p1 = p3;
            p2=p3;
        }
    }
    ListNode* Group(ListNode* head)
    {
        struct ListNode *p0 = NULL;//记录每段的前指针
        struct ListNode *p1 = head;//指向头节点
        struct ListNode *p2 = head->next;//p2指向第二个指针
            while(p1!=NULL)//完成小组逆序
            {
                p1->next=p0;
                p0=p1;
                p1=p2;
                if(p2!=NULL)p2=p2->next;
            }
        return p0;
    }
};

以上C++代码有误，但是实在找不出哪里错了。。。自测数据过得去。

这题有点难度，链表反转还有衔接。

大佬的Java代码：

public class Solution {
    public static ListNode reverseKGroup(ListNode head, int k) {
		if(head == null || head.next == null || k < 2) return head;
		ListNode dummy = new ListNode(0);
		dummy.next = head;
		ListNode pre = dummy, cur = head, temp;
		int len = 0;
		while (head != null) {
			len ++ ;
			head = head.next;
		}
		for (int i = 0; i < len / k; i ++ ) {
			for (int j = 1; j < k; j ++ ) {
				temp = cur.next;
				cur.next = temp.next;
				temp.next = pre.next;
				pre.next = temp;
			}
			pre = cur;
			cur = cur.next;
		}
		return dummy.next;
	}
}