1-5 LC25 K个一组翻转链表 LC61 旋转链表 LC24 两两交换链表中的节点 Java力扣刷题笔记

为了在这周刷完链表反转、链表删除相关的题目 今明两天要刷6道题！提升效率 疯狂刷题 冲冲冲！

今日的三道题与昨天的两题一样 依旧是链表的反转部分的练习

LC25 K个一组翻转链表

LC25
第一次遇到困难的题 有点小紧张。。

1.读题

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

2.思路

【1】解题思路

依旧是参考力扣大佬的题解~

1. 链表分区——已翻转；待翻转；未翻转
2. 每次翻转前 要确定翻转链表的范围 —— 因为是k个一组 所以通过k来跑一个循环
3. 记录翻转链表的前驱和后继 方便翻转完成后把已翻转和未翻转部分连接起来
4. 初试需要两个变量——pre和end pre代表待翻转链表的前驱 end代表翻转链表的末尾
5. 经过k此循环 end到达末尾 记录待翻转链表的后继next = end.next
6. 翻转链表 然后将三部分链表连接起来 然后重置pre和end指针 然后进入下一次循环
7. 考虑特殊情况——翻转部分长度不足k时 在定位end完成后 end == null —— 说明题目已经完成 直接返回即可~

【2】代码逻辑

【1】判空/判单节点 直接返回head
【2】定义虚拟头节点 放置处问题

【3】虚拟头节点的next指向head

【4】初始化pre——待翻转链表的前驱 和 end——翻转链表的末尾
二者都指向虚拟头节点

【5】进入循环！
循环的作用——找到需要翻转的链表的结尾（判定方法为 end.next == null）
这判定 真的妙鸭

【6】如果end为空 则说明链表的节点数<k 不翻转 直接跳出总循环

【7】记录下end.next 方便后面链接链表

【8】熟悉的链表反转的函数要写一下！
这里跟LC206 反转链表是一样滴

【9】开始翻转链表

【10】得到结果
输出虚拟头节点指向的链表（已经根据题意做了翻转）

3.Java代码

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null || head.next == null){
            return head;
        }
        //定义虚拟头节点
        ListNode dummy=new ListNode(0);
        //假节点的next指向head。
        // dummy->1->2->3->4->5
        dummy.next=head;
        //初始化pre和end都指向dummy。pre指每次要翻转的链表的头结点的上一个节点。end指每次要翻转的链表的尾节点
        ListNode pre=dummy;
        ListNode end=dummy;

        while(end.next!=null){
            //循环k次，找到需要翻转的链表的结尾,这里每次循环要判断end是否等于空,因为如果为空，end.next会报空指针异常。
            //dummy->1->2->3->4->5 若k为2，循环2次，end指向2
            for(int i=0;i<k&&end != null;i++){
                end=end.next;
            }
            //如果end==null，即需要翻转的链表的节点数小于k，不执行翻转。
            if(end==null){
                break;
            }
            //先记录下end.next,方便后面链接链表
            ListNode next=end.next;
            //然后断开链表
            end.next=null;
            //记录下要翻转链表的头节点
            ListNode start=pre.next;
            //翻转链表,pre.next指向翻转后的链表。1->2 变成2->1。 dummy->2->1
            pre.next=reverse(start);
            //翻转后头节点变到最后。通过.next把断开的链表重新链接。
            start.next=next;
            //将pre换成下次要翻转的链表的头结点的上一个节点。即start
            pre=start;
            //翻转结束，将end置为下次要翻转的链表的头结点的上一个节点。即start
            end=start;
        }
        return dummy.next;


    }
    //链表翻转
    // 例子：   head： 1->2->3->4
    public ListNode reverse(ListNode head) {
         //单链表为空或只有一个节点，直接返回原单链表
        if (head == null || head.next == null){
            return head;
        }
        //前一个节点指针
        ListNode preNode = null;
        //当前节点指针
        ListNode curNode = head;
        //下一个节点指针
        ListNode nextNode = null;
        while (curNode != null){
            nextNode = curNode.next;//nextNode 指向下一个节点,保存当前节点后面的链表。
            curNode.next=preNode;//将当前节点next域指向前一个节点   null<-1<-2<-3<-4
            preNode = curNode;//preNode 指针向后移动。preNode指向当前节点。
            curNode = nextNode;//curNode指针向后移动。下一个节点变成当前节点
        }
        return preNode;

    }


}

LC61 旋转链表

LC61

1.读题

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

2.思路

【1】解题思路

又是偷懒看题解的一题hhh
参考 Java 快慢指针，逐行注释（100%，67%）

搭配图解 比较清晰！
这里使用快慢指针法~
有木有很熟悉！
1-3 LC202 快乐数 C++ Java力扣刷题笔记 快慢指针法！要理解透彻！！

另外 快慢指针经常被用来解决需要反向操作链表的问题。

主要思想是，让快指针先走k次，然后慢指针再和快指针一起走，当快指针走完时，慢指针会刚好来到k的位置。
此时慢指针的下一个节点就是新的头节点，慢指针当前的节点就是尾节点。
最后把快指针当前的节点链上原来的头节点即可。

【2】代码逻辑

【1】设置快慢指针
【2】统计链表长度size（以上两步老套路了哈哈哈）

【3】移动位置量k对链表长度size求余

【4】用快指针找倒数第k+1个元素

【5】用慢指针去定位到新链表的尾部

【6】将之前的链表连成环

【7】找到新链表的头节点
因为连成环了嘛 慢节点定位的是新链表尾部 slow.next自然就是新链表的头节点

【8】最后切断环 并返回结果

3.Java代码

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        // 首先把链表为空的特殊情况处理掉
        if (head == null) return null;
        // 然后设置快慢指针
        ListNode fast = head, slow = head;
        int size = 0;
        // 统计链表长度
        while (fast != null) {
            size++;
            fast = fast.next;
        }
        // 然后求余，因为如果是链表长度倍数的话，就没必要那样转了。
        k %= size;
        fast = head;
        // 用快指针去找到倒数第 k+1 个元素
        for (int i = 0; i < k; ++i) {
            if (fast.next == null) fast = head;
            else fast = fast.next;
        }
        // 用慢指针去定位到新链表的尾部
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        // 将原来的链表连成环
        fast.next = head;
        // 找到新链表的头节点
        head = slow.next;
        // 再把环切断
        slow.next = null;
        return head;
    }
}

LC24 两两交换链表中的节点

LC24

1.读题

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

2.思路

【1】解题思路

偷个懒 使用先只使用递归的思维进行简单粗暴地解题
之后会陆续了解其他思想
参考题解——动画演示 迭代+递归 24. 两两交换链表中的节点

ps:递归yyds！

【2】代码逻辑

动画演示思路

疯狂递归法
【1】熟悉的退出条件

【2】这里举个栗子

先保存节点“2”

【3】继续进行递归 处理节点 “3 -> 4”

结束递归后 3->4的翻转就成功辽——变为"4->3"

结束递归后 head节点将指向4 变为1->4->3

【4】最后完成第一对的翻转

并返回最终结果

3.Java代码

class Solution {
	public ListNode swapPairs(ListNode head) {
		//递归的终止条件
		if(head==null || head.next==null) {
			return head;
		}
		//假设链表是 1->2->3->4
		//这句就先保存节点2
		ListNode tmp = head.next;
		//继续递归，处理节点3->4
		//当递归结束返回后，就变成了4->3
		//于是head节点就指向了4，变成1->4->3
		head.next = swapPairs(tmp.next);
		//将2节点指向1
		tmp.next = head;
		return tmp;
	}
}