代码随想录第四天(链表~)

最新推荐文章于 2024-08-23 08:14:22 发布

Punk Boy

最新推荐文章于 2024-08-23 08:14:22 发布

阅读量867

点赞数 26

文章标签：链表数据结构

本文链接：https://blog.csdn.net/weixin_47455684/article/details/134757893

版权

今日学习的文章

写代码的时候最好对照图像的逻辑来写，可以画个图，模拟，不会太乱

两两交换链表中的节点

用虚拟头结点，这样会方便很多。

本题链表操作就比较复杂了，建议大家先看视频，视频里我讲解了注意事项，为什么需要temp保存临时节点。

题目链接/文章讲解/视频讲解：代码随想录

看到题目的第一想法

这道题的目标时要将链表中的节点，每两个两个进行交换，我看到题目第一时间选择画图，以及回忆了之前链表反转的代码，但是在控制指针时还是容易乱

看到代码随想录之后的想法

1.设置头节点:卡哥视频中的关键所在，如果要操作两个节点的反转，必须cur节点要在这两个节点之前才方便操作，相当于用一个前置节点操作它的后置节点和后置的后置节点之间的反转

2.需要考虑while循环的终止条件，到链表最后，奇数时候，cur.next.next为null,偶数时候cur.next为null

3.cur指向的位置相当关键，同时还需要设置临时变量

自己实现过程中遇到的困难

2.需要考虑while循环的终止条件，到链表最后，奇数时候，cur.next.next为null,偶数时候cur.next为null

3.cur指向的位置相当关键，同时还需要设置临时变量，一个用来定位前一个节点，一个用来连接后续的节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        //两两交换，需要框起来？
        //设置头节点:卡哥视频中的关键所在，如果要操作两个节点的反转，必须cur节点要在这两个节点之前才方便操作
        //相当于用一个前置节点操作它的 后置节点和后置的后置节点 之间的反转
        //cur->[反转1]-->[反转2]
        //需要考虑while循环的终止条件，到链表最后，奇数时候，cur.next.next为null,偶数时候cur.next为null
        ListNode newHead = new ListNode();
        newHead.next = head;
        ListNode cur = newHead;
        ListNode temp = new ListNode();
        ListNode temp1 = new ListNode();
        while(cur.next!=null&&cur.next.next!=null){
            temp = cur.next;
            //下一个要反转的目标
            temp1 = cur.next.next.next;
            //前置节点指向后置的后置
            cur.next = cur.next.next;
            //后置节点的反转
            cur.next.next = temp;
            cur = temp;
            cur.next = temp1;
        }
        return newHead.next;

    }
}

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

双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向第N个节点的前一个节点，建议先看视频。

题目链接/文章讲解/视频讲解：代码随想录

看到题目的第一想法

用暴力or堆栈，没想到卡哥的方法

看到代码随想录之后的想法

还是经典的双指针，快指针走了n+1步之后慢指针再开始同步走(为什么是n+1，因为删除节点需要在该节点之前才能删除该节点，所以快指针比慢指针快n+1)

自己实现过程中遇到的困难

1快指针应该要走多少步？n+1步因为slow要指向倒数第n个元素的前一个，所以fast要比slow快n+1
2需要添加虚拟头节点，开始时快慢指针都是指向头节点，删除的是slow的下一个节点
3while循环中的条件为fast！=null

我自己实现的时候while循环考虑的是 fast.next!=null

1 这时快指针只需要走n步，也是可行的

2 因为快指针走到最后时不会走到null，而是走到最后一个元素来终止循环

例如:删除倒数第一个时，fast会指向倒数第一个元素，而slow会指向倒数第一个节点的前一个节点，其他的也可以这样考虑

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
/*class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //暴力解法，遍历总长度，算出总长度-n
        //使用栈找到倒数第N-1个
        //卡哥思路：双指针，一个快指针先走n步，慢指针再开始走
        //快指针应该要走多少步？n+1步 因为slow要指向倒数第n个元素的前一个，所以fast要比slow快1
        //需要添加虚拟头节点，开始时快慢指针都是指向头节点，删除的是slow的下一个节点
        //while循环中的条件为fast！=null
        
        ListNode newHead= new ListNode();
        newHead.next = head;
        ListNode fastIndex = newHead;
        ListNode slowIndex = newHead;
        //fast先走
        for(int i=0;i<n+1;i++){
            if(fastIndex==null){
                return newHead.next;
            }
            fastIndex = fastIndex.next;
        }
        //一起往后走
        while(fastIndex!=null){
            fastIndex = fastIndex.next;
            slowIndex = slowIndex.next;
        }
        //删除slow后面的元素
        slowIndex.next = slowIndex.next.next;
        return newHead.next;
    }
}*/
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //暴力解法，遍历总长度，算出总长度-n
        //使用栈找到倒数第N-1个
        //卡哥思路：双指针，一个快指针先走n步，慢指针再开始走
        //快指针应该要走多少步？n+1步 因为slow要指向倒数第n个元素的前一个，所以fast要比slow快1
        //需要添加虚拟头节点，开始时快慢指针都是指向头节点，删除的是slow的下一个节点
        //while循环中的条件为fast！=null
        //若n步也可以 while循环中的条件为fast.next!=null
        
        ListNode newHead= new ListNode();
        newHead.next = head;
        ListNode fastIndex = newHead;
        ListNode slowIndex = newHead;
        //fast先走
        for(int i=0;i<n;i++){
            if(fastIndex.next==null){
                return newHead.next;
            }
            fastIndex = fastIndex.next;
        }
        //一起往后走
        while(fastIndex.next!=null){
            fastIndex = fastIndex.next;
            slowIndex = slowIndex.next;
        }
        //删除slow后面的元素
        slowIndex.next = slowIndex.next.next;
        return newHead.next;
    }
}

面试题 02.07. 链表相交

本题没有视频讲解，大家注意数值相同，不代表指针相同。

题目链接/文章讲解：代码随想录

看到题目的第一想法

计算出两个链表的长度再相减，然后再用双指针走

看到代码随想录之后的想法

计算出两个链表的长度再相减得到offset，再通过长的先走完offset后，同步往下走

自己实现过程中遇到的困难

1 中间考虑到时用元素的值相等来判断是否相遇，其实是错误的，正确的方式应该是用元素的地址相等来判断是否相遇

2 该题是判断重合的点在哪，所以两个链表长度需要规划为相等的，才能逐步进行判断，我写的时候差点误把长度相等的点(就是走了offset位后两个链表长度相同的起始点)视为了重合点了

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //先走到最后，看两个链表长度的大小
        //然后根据差值，长的先走，慢的再走
        ListNode listNodeA = headA;
        ListNode listNodeB = headB;
        int countA=0;
        int countB=0;
        while(listNodeA!=null)
        {
            countA++;
            listNodeA = listNodeA.next;
        }
        while(listNodeB!=null){
            countB++;
            listNodeB = listNodeB.next;
        }
        //相等不需要特殊处理，而是一起往下走
        /*if(countA==countB){
            if(headA == headB){
                return headA;
            }else{
                return null;
            }
        }*/
        listNodeA = headA;
        listNodeB = headB;
        int offset = countA>countB?countA-countB:countB-countA;
        //根据差值，A先走offset
        for(int i = 0;i<offset;i++){
            if(countA<countB){
                listNodeB = listNodeB.next;
            }
            if(countA>countB){
                listNodeA = listNodeA.next;
            }
        }
        //然后再一起走
        while(listNodeA!=null&&listNodeB!=null){
            //不能用值相等来判断，要用节点相等来判断
            if(listNodeA==listNodeB){
                return listNodeA;
            }
            listNodeA = listNodeA.next;
            listNodeB = listNodeB.next;
        }
        return null;



    }
}

142.环形链表II

算是链表比较有难度的题目，需要多花点时间理解确定环和找环入口，建议先看视频。

题目链接/文章讲解/视频讲解：代码随想录

看到题目的第一想法

通过双指针来判断是否有环，一个每次走两个，一个每次走一个，但是不太确定这个方法是否是对的，不知道两个指针会不会在环里相遇

找起始点没想到方法

看到代码随想录之后的想法

1 如何检测链表有环双指针？
2 第一个走一次，第二个指针走两次会相遇吗？因为快指针相当于每次以一个节点的速度去靠近慢指针，所以他们一定会相遇
3 当慢指针进入环的时候，快指针总会在慢指针走一圈没走完时追上慢指针?
因为快指针是慢指针的两倍速度，当满指针走完一圈时，快指针走了两圈了(快指针一定能追上慢指针)
4 快慢指针交汇点有相关的数学证明

起点走到入口为X，快指针在环里遇到慢指针为Y，Y到X的距离为Z
慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>
X=Z+(n-1)(Y+Z) Y+Z都可以视为走的圈数而已
当Z从起点出发到交汇点，X也从起点出发到交汇点,两者最终会在环的起点相遇
则当Z走向交汇点时，X也走向交汇点

自己实现过程中遇到的困难

起点走到入口为X，快指针在环里遇到慢指针为Y，Y到X的距离为Z
慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>

这里让出一个(Y+Z) 也就是一圈

(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>
X=Z+(n-1)(Y+Z) Y+Z都可以视为走的圈数而已当n=1时X=Z
当Z从起点出发到交汇点，X也从起点出发到交汇点,两者最终会在环的起点相遇
则当Z走向交汇点时，X也走向交汇点

我自己写的方法复杂了一点(注释中的方法)，其实可以简单点，把找起点的操作就放在while循环中，最后统一返回null

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
/*public class Solution {
    public ListNode detectCycle(ListNode head) {
        //如何检测链表有环 双指针？
        //第一个走一次，第二个指针走两次？因为快指针相当于每次以一个节点的速度去靠近慢指针，所以他们一定会相遇
        //当慢指针进入环的时候，快指针总会在慢指针走一圈没走完时追上慢指针
        //因为快指针是慢指针的两倍速度，当满指针走完一圈时，快指针走了两圈了(快指针一定能追上慢指针)
        //起点走到入口为X，快指针在环里遇到慢指针为Y，Y到X的距离为Z
        //慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>
        // X=Z+(n-1)(Y+Z) Y+Z都可以视为走的圈数而已 
        //当Z从起点出发到交汇点，X也从起点出发到交汇点,两者最终会在环的起点相遇
        //则当Z走向交汇点时，X也走向交汇点
        ListNode slowIndex = head;
        ListNode fastIndex = head;
        if(head==null){
            return null;
        }
        while(fastIndex!=null&&fastIndex.next!=null){
            fastIndex = fastIndex.next.next;
            slowIndex = slowIndex.next;
            if(fastIndex==slowIndex){
                break;
            }
        }
        if(fastIndex==null||fastIndex.next==null){
            return null;
        }
        ListNode headIndex = head;
        while(headIndex!=fastIndex){
            headIndex = headIndex.next;
            fastIndex = fastIndex.next;
        }
        return headIndex;
    }
}*/
public class Solution {
    public ListNode detectCycle(ListNode head) {
        //如何检测链表有环 双指针？
        //第一个走一次，第二个指针走两次？因为快指针相当于每次以一个节点的速度去靠近慢指针，所以他们一定会相遇
        //当慢指针进入环的时候，快指针总会在慢指针走一圈没走完时追上慢指针
        //因为快指针是慢指针的两倍速度，当满指针走完一圈时，快指针走了两圈了(快指针一定能追上慢指针)
        //起点走到入口为X，快指针在环里遇到慢指针为Y，Y到X的距离为Z
        //慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>
        // X=Z+(n-1)(Y+Z) Y+Z都可以视为走的圈数而已 
        //当Z从起点出发到交汇点，X也从起点出发到交汇点,两者最终会在环的起点相遇
        //则当Z走向交汇点时，X也走向交汇点
        ListNode slowIndex = head;
        ListNode fastIndex = head;
        if(head==null){
            return null;
        }
        while(fastIndex!=null&&fastIndex.next!=null){
            fastIndex = fastIndex.next.next;
            slowIndex = slowIndex.next;
            if(fastIndex==slowIndex){
                ListNode headIndex = head;
                while(headIndex!=fastIndex){
                    headIndex = headIndex.next;
                    fastIndex = fastIndex.next;
                }
                return headIndex;
            }
        }
        
            return null;
        
}
}

Punk Boy

关注

26
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
代码随想录第四天(链表~)

慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>(X+Y)=(n-1)(Y+Z)+Z+Y=>X=(n-1)(Y+Z)+Z==>慢指针走了(X+Y) 快指针走了(Y+Z)n+X+Y = 2(X+Y)==>(X+Y) = n(Y+Z)==>双指针的操作，要注意，删除第N个节点，那么我们当前遍历的指针一定要指向第N个节点的前一个节点，建议先看视频。因为快指针是慢指针的两倍速度，当满指针走完一圈时，快指针走了两圈了(快指针一定能追上慢指针)
复制链接

扫一扫