力扣25_K个一组翻转链表

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

示例:
在这里插入图片描述
算法思想
方法一:递归
就按示例这样,对链表调用reverseKGroup(head, 2),即以2个节点为一组反转链表,假设前两个节点已经反转,如图所示
在这里插入图片描述
后面的这些节点也是一条链表,而且规模(长度)比原来这条链表小,这就叫子问题。
我们可以直接递归调用reverseKGroup(head, 2),因为子问题和原问题的结构完全相同,这就是所谓的递归性质。
待子问题反转后,再把两个组连接上
在这里插入图片描述
伪代码可以表示为:

public ListNode reverseKGroup(ListNode head, int k) {
	
	//反转[a,b)的链表,a到b的距离为k,表头以newHead返回
	ListNode newHead = reverseList(a, b);

	//递归反转以b开头,k为一组的链表
	ListNode nextNode = reverseKGroup(b, k);

	//组与组之间连接
	a.next = nextNode;

	return newHead;

在这里插入图片描述

那么,如何反转[a, b)之间的链表呢?
我们这里采用迭代方法,如图所示,记录当前节点以及前驱节点,在改变指针方向的时候临时记录当前节点的下一节点,改变之后同时移动前驱和当前节点
在这里插入图片描述

public ListNode reverseList(ListNode a, ListNode b) {
        ListNode prev = null;
        ListNode cur = a;
        while(cur != null && cur != b){
            ListNode nextTemp = cur.next;
            cur.next = prev;
            prev = cur;
            cur = nextTemp;
        }
        return prev;
    }

整体的代码为:

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head == null) return null;
        ListNode a = head;
        ListNode b = head;
        //找到下一个待反转的位置 发现子问题和原问题完全相同
        for(int i = 0; i < k; i++){
            if(b == null){
                return head;
            }
            b = b.next;
        }

        ListNode newHead = reverseList(a, b); //k个节点反转
        ListNode nextHead = reverseKGroup(b, k); //递归
         
        a.next = nextHead;
        return newHead;

    }

    //反转区间[a,b)的链表
    public ListNode reverseList(ListNode a, ListNode b) {
        ListNode prev = null;
        ListNode cur = a;
        while(cur != null && cur != b){
            ListNode nextTemp = cur.next;
            cur.next = prev;
            prev = cur;
            cur = nextTemp;
        }
        return prev;
    }
}

复杂度分析
时间复杂度:需要遍历一遍链表,故为O(n)
空间复杂度:运用到了递归,为O(n)

方法二:直接K个一组反转
其实思路和方法一也差不多,就是走K步,反转一下,再走K步,再反转一下,如果走不完K步,直接返回。
注意:我们这里引入临时节点dummy,避免讨论

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        ListNode pre = dummy;
        ListNode end = pre;

        while(end.next!=null) {
            
            for(int i = 0; i < k && end!=null; ++i) end = end.next;
            if(end == null) break;
            ListNode start = pre.next;
            ListNode nextNode = end.next;
            end.next = null;
            pre.next = reverseList(start);
            start.next = nextNode;
            pre = start;

            end = pre;
        }
        return dummy.next;

    }

    //反转链表
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode nextNode = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nextNode;
        }
        return pre;
    }
}

复杂度分析
时间复杂度:O(n*k)
空间复杂度:O(1)

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 1024 设计师:白松林 返回首页