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

目录

今日学习的文章

两两交换链表中的节点 

看到题目的第一想法

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

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

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

看到题目的第一想法

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

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

面试题 02.07. 链表相交  

看到题目的第一想法

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

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

142.环形链表II  

看到题目的第一想法

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

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


今日学习的文章


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

两两交换链表中的节点 

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

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

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

看到题目的第一想法

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

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

    

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

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

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

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

           1.设置头节点:卡哥视频中的关键所在,如果要操作两个节点的反转,必须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

面试题 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;icountB){
                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也走向交汇点

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

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

        起点走到入口为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;
        
}
}

你可能感兴趣的:(链表,数据结构)