代码随想录day4(环形链表是根硬骨头)

cookieeee_

已于 2024-07-22 13:04:17 修改

阅读量907

点赞数 20

分类专栏：代码随想录文章标签： java 链表数据结构

于 2024-07-22 13:02:10 首次发布

本文链接：https://blog.csdn.net/cookieeee_/article/details/140595313

版权

代码随想录专栏收录该内容

9 篇文章 0 订阅

订阅专栏

今日任务

24. 两两交换链表中的节点

19.删除链表的倒数第N个节点

面试题 02.07. 链表相交

142.环形链表II

24. 两两交换链表中的节点

整体思路

偶个数结点两两交换，奇个数结点，最后一个不动

虚拟头节点解法

因为想修改节点，必须要知道前一个结点，同时保存好接下来的结点

class Solution {  
    public ListNode swapPairs(ListNode head) {  
        ListNode dummy_head = new ListNode(-1);  
        dummy_head.next = head;  
        ListNode cur = dummy_head;  
          
        while (cur.next != null && cur.next.next != null) {  
            ListNode temp = cur.next; // 第一个节点  
            ListNode tempNext = cur.next.next; // 第二个节点  
              
            // 交换节点  
            cur.next = tempNext; // 跳过第一个节点  
            temp.next = tempNext.next; // 第一个节点指向第二个节点的下一个节点  
            tempNext.next = temp; // 第二个节点指向第一个节点  
              
            // 移动cur到已经交换过的节点对中的第二个节点  
            cur = cur.next.next;  
        }  
          
        return dummy_head.next;  
    }  
}

递归解法

// 递归版本
class Solution {
    public ListNode swapPairs(ListNode head) {
        // base case 退出提交
        if(head == null || head.next == null) return head;
        // 获取当前节点的下一个节点
        ListNode temp = head.next;
        // 进行递归
        ListNode newNode = swapPairs(temp.next);
        // 这里进行交换
        temp.next = head;
        head.next = newNode;

        return temp;
    }
}

递归思路

19.删除链表的倒数第N个节点

关键是找到倒数的结点--解决方法，使用快慢指针，当快慢指针相差的元素等于n+1时，并将快慢指针同时向后移，当快指针移动到结尾时，慢指针指向的就是要删除节点的前一个结点

虚拟头节点

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy_head=new ListNode(0);
        dummy_head.next=head;//要给虚拟指针赋予真实的指针位置
        ListNode fast=dummy_head;//设立虚拟指针的目的是头尾结点的处理规则和普通结点一致
        ListNode slow=dummy_head;
        for(int i=0;i<=n;i++){
            fast=fast.next;
        }
        while(fast!=null){
            fast=fast.next;
            slow=slow.next;
        }
        slow.next=slow.next.next;
        return dummy_head.next;

    }
}

面试题 02.07. 链表相交

思路

此题不是很好理解，强调一点：是由于两条链表相交而引出的数值相等、指针位置相等的条件

那么既然两条链表相交成一条链表，则说明从相交点开始相等，~~那么就应该将两条链表末端对齐，从后向前找到相交点~~（错误，从后向前无法移动），两个链表从短链表的头节点位置开始(这时应该算好两者差值，长链表从差值开始)，比较，若值相等则为相交点

初始化指针：curA指向headA，curB指向headB。
调整较长链表：如果lenB大于lenA，交换lenA和lenB，同时交换curA和curB，确保curA指向的是较长的链表。
求长度差：gap是两个链表长度的差值。
对齐指针：通过while循环，让curA指针移动gap步，这样两个指针就处于同一起点上。
同步遍历：使用while循环，同步移动curA和curB，如果在某一点curA等于curB，则找到了相交节点，返回该节点。

难点

~~这道题的难点在于如何从后往前找到相交点~~，

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA=headA;
        ListNode curB=headB;
        //比较长短
        int lenA=0;
        int lenB=0;
        while(curA!=null){
            lenA++;
            curA=curA.next;
        }
        while(curB!=null){
            lenB++;
            curB=curB.next;
        }
        //更新位置
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            //1. swap (lenA, lenB);
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;
            //2. swap (curA, curB);
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }
        
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap-- > 0) {
            curA = curA.next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;


    }
}

142.环形链表II

思路

需要解决两个问题：

判断是否有环
如何找到环的入口

1.判断是否有环

用快慢指针来判断，若快指针的步长为2，慢指针步长为1，那么快指针就相对于慢指针以一个结点为步长在靠近(这里可以看作慢指针不动，快指针一一个结点的速度靠近)，若有环，则二者一定会相遇；若无环，快指针会指向null

2.如何找到环的入口

不确定快慢指针相遇的点是否是入口，可以通过以下数学推理来证明：

头节点到环的入口距离设为x，入口到快慢指针相遇距离为y，相遇距离到入口为z(此时y+z是一个整环)，当快慢指针相遇时，slow=x+y;fast=x+n(y+z); n表示相遇之前快指针在环里转的圈数

可以得出等式: 2(x+y)=x+n(y+z),

x+y=n(y+z),

x=n(y+z)-y,n>=1,

x=(n-1)(y+z)+z,

当转的圈数为1时，x=z，说明在快慢指针相遇在入口，若n不等于1也没关系，由于y+z是一圈的长度，说明快指针转了n-1圈和慢指针相遇在入口，可以推出当快慢指针相遇之后，head到入口距离(即入口位置)等于相遇位置再次走到入口(即z)

此时代码部分应该定义两个新指针，一个为头节点，另一个为相遇的位置，当两者相遇时，走了x+z即2x或2z，那么一者走到距离就是x

综上所述，可以确定入口位置

疑点

慢指针为什么没有转了几圈之后跟快指针相遇，也可以用数学推理来证明：

此图将环展开

fast走到该位置，slow从环入口2进入环，slow走到下一次环的入口(即环入口3)距离为n，fast走到环入口3距离为k+n，fast的速度是slow的二倍，所以在同等时间下，fast走了2n

此时得到等式： 2n?k+n;

2n?k，m为正整数，且k一定小于n，所以2n>k+n，即fast在同等时间走到距离要在环入口3之后，二者一定会相遇

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast=head;
        ListNode slow=head;
        
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(fast==slow){//有环
                ListNode f=fast;
                ListNode s=head; 
                //两个指针，从头结点和相遇节点各走一步，直到相遇，相遇点为入口
                while(f!=s){
                    f=f.next;
                    s=s.next;
                }
                return f;
            }
            
        }
        return null;
    }
}