代码随想录第四天|24.两两交换链表中的节点、19.删除链表的倒数第n个节点、160.链表相交、142.环形链表-CSDN博客

本文链接：https://blog.csdn.net/suanheuo/article/details/127641000

思路：只要使用简单的模拟即可，本题中使用虚拟头结点能够相对更加方便一些：由于我们设定的虚拟头结点是不会变化的返回只需要返回虚拟头结点的next即可，

ac代码如下：

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) {
    if(head == null){
        return null;
    }
    //使用虚拟头结点完成此问题？
        ListNode dummyhead = new ListNode();
    dummyhead.next = head;
    ListNode pre = new ListNode();
    ListNode cur = new ListNode();
    ListNode tmp = new ListNode();
    ListNode tmp2 = new ListNode();
    pre = dummyhead;
    while(pre.next != null && pre.next.next != null){
        cur = pre.next;
        tmp = cur.next;
        tmp2 = tmp.next;
        pre.next = tmp;
        tmp.next = cur;
        cur.next = tmp2;
        pre = pre.next.next;

    }
    return dummyhead.next;
    }
}

题目链接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

初见思路：就是很朴素的进行一次遍历后得到总节点数，然后用总结点数减去倒数的节点数后删除该节点，最终返回即可

利用双指针，首先将快指针走倒数n步，然后快慢指针同时前进，当快指针为空时停止即可

注意应当两指针应当在同起点开始

ac代码如下：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head == null) return null;
        ListNode dummyhead = new ListNode();
        dummyhead.next = head;
        ListNode fast = new ListNode();
        ListNode slow = new ListNode();
        fast = dummyhead;
        slow = dummyhead;
        while(n-- > 0){
            fast = fast.next;
        }
        while( (fast.next) != null){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next  = slow.next.next;
        return dummyhead.next;

//        int count = 0;
//        ListNode tmp = dummyhead;
//        while(tmp.next != null){
//            count++;
//            tmp = tmp.next;
//        }
//        tmp = dummyhead;
//        int ans = count - n;
//        while(ans-- > 0){
//            tmp = tmp.next;
//        }
//        tmp.next = tmp.next.next;
//        return dummyhead.next;
    }
}

题目链接：面试题 02.07. 链表相交 - 力扣（LeetCode）

初见思路：利用两层循环进行重复判断，若相同则直接返回

代码如下：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        while (headA.next != null) {
            while (headB.next != null) {
                headB = headB.next;
                if (headA.next == headB.next) {
                    return headA.next;
                }
                headA = headA.next;
            }
        }
        return null;
    }
}

这种做法的时间复杂度太高，有许多用例通不过，不可采纳

更优的思路：

两个链表若是有相交部分，则其尾部一定还是相交的，则我们将他们的尾部对齐，具体做法为分别求出两链表长度，让更长的链表指针先向前移动长出的距离，随即让两个指针同时反复向前比对，若相同则直接返回，若不同则继续向前，直至指向null为止

具体ac代码如下：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        int lengtha = 0;
        int lengthb = 0;
        ListNode tmpa = headA;
        ListNode tmpb = headB;
        while(tmpa != null){
            lengtha++;
            tmpa = tmpa.next;
        }
        while(tmpb  != null){
            lengthb++;
            tmpb = tmpb.next;
        }
        tmpa = headA;
        tmpb = headB;
        int syn;
        if(lengtha > lengthb){
            syn = lengtha-lengthb;
            while (syn-- > 0){
                tmpa = tmpa.next;
            }
            while(tmpa != tmpb && tmpa != null){
                tmpa = tmpa.next;
                tmpb = tmpb.next;
            }
            if(tmpa != null){
                return tmpa;
            }
            else 
            return null;
        }
        else{
            syn = lengthb - lengtha;
            while (syn-- > 0){
                tmpb = tmpb.next;
            }
            while(tmpa != tmpb && tmpa != null){
                tmpa = tmpa.next;
                tmpb = tmpb.next;
            }
            if(tmpa != null){
                return tmpa;
            }
            else
                return null;
        }

    }
}

题目链接：142. 环形链表 II - 力扣（LeetCode）

初见真的是没有一点思路，不知道应当如何发现链表中有环，只得去看了代码随想录中的题解，不得不说这道题的解法十分精彩

解题思路：

有两个难点：

怎么发现环
怎么找出开始入环的第一个节点

环的发现可以通过快慢两个指针来实现，通过判断指针的指向地址值是否相同来判断两个指针是否指向同个地址，若指向同个地址，则链表中存在环结构。具体实现为：快指针每次走两个单位，慢指针每次走一个单位，这样就可判断出是否有环存在

第一个节点可以通过快慢指针的前进距离进行判断，

$设到入口距离为 x ，入口到相遇时的节点数为 y ，剩下的距离为 z ，如图：$

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bqox1bUj-1667306479109)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/d75657c2-b46d-416b-8fb9-ec344fdfc4c4/Untitled.png)]

$则有 s l o w 走了 x + y 时， f a s t 走了 x + y + n (z + y), 且有 2 (x + y) = x + y + n (z + y)$

求x则得到:

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

故当 n=1 或更多时，x = z + n圈，n为更多值时，并无需关心其具体值，x = z

ac代码如下：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){
                ListNode tmp1 = fast;
                ListNode tmp2 = head;
                while(tmp1 != tmp2){
                    tmp1 = tmp1.next;
                    tmp2 = tmp2.next;
                }
                return tmp2;
            }

        }
        return null;
    }
}

感觉哪怕再做一次也是做不出来的水平，这道题确实很巧妙！