代码随想录 day4

两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

• 输入：head = [1,2,3,4]
• 输出：[2,1,4,3]

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

链表是默认定义了好的，如下：（后面题目类同）

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; }
}

思路

先虚拟一个头节点，然后命名三个节点分别是pre（前），cur，last（后）

然后cur和last交换，之后后移

代码

public static ListNode swapPairs(ListNode head) {
    if (head==null||head.next==null){
        return head;
    }
    ListNode dummyNode=new ListNode(-1,head);
    ListNode per=dummyNode;
    ListNode cur=head;

    while (cur!=null){
        ListNode last=cur.next;
        if (last==null){
            break;
        }
        //两节点交换
        per.next=last;
        cur.next=last.next;
        last.next=cur;
        //三个节点后移
        per=cur;
        cur=cur.next;

    }
    return dummyNode.next;
}

代码随想录中有一个递归的版本

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

        return next;
    }

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

• 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
• 进阶：你能尝试使用一趟扫描实现吗？
• 输入：head = [1,2,3,4,5], n = 2
• 输出：[1,2,3,5]

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

思路

用两个for可以解决，但题目中说要一趟实现，我感觉就需要用类似双指针的方法，把删除节点的前一个节点记录下来

自己写的如下

代码

public static ListNode removeNthFromEnd(ListNode head, int n) {
    if (n<=0){
        return head;
    }
    ListNode dummy=new ListNode(-1,head);
    ListNode pre=dummy;//要删除节点的前一个节点
    ListNode last=head;//寻找最后一个节点
    while (last.next!=null){
        last=last.next;
        n--;
        if (n<=0){
            pre=pre.next;
        }
    }
    ListNode cur=pre.next;
    ListNode curAfter=cur.next;
    pre.next=curAfter;
    return dummy.next;
}

链表相交

给你两个单链表的头节点headA 和 headB ，请你找出并返回两个单链表相交的起始节点。

如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

​ a1->a2->

​ c1->c2->c3

b1->b2->b3->

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

输入：intersectVal= 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1

输出：Intersected at ‘2’

​ 3->

​ 2->4

0->9->1->

链表相交

思路

这题没写出来，直接看的题解。

求两个链表交点节点的指针。 交点不是数值相等，而是指针相等。

求出两个链表的长度，并求出两个链表长度的差值，然后让两个链表末尾对其之后，指针指到特点位置，如下

比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

否则循环退出返回空指针

代码

//求两个链表的长度
    ListNode curA=headA;
    ListNode curB=headB;
    int lenA=0,lenB=0;
    while (curA!=null){
        lenA++;
        curA=curA.next;
    }
    while (curB!=null){
        lenB++;
        curB=curB.next;
    }
    curA = headA;
    curB = headB;
    //这里假设A的长度比B长，如果短，就把长的那个设置为A
    if (lenB>lenA){
        int temp=lenA;
        lenA=lenB;
        lenB=temp;
        ListNode tempNode=curA;
        curA=curB;
        curB=tempNode;
    }
    ///求长度差，末尾对其两个链表
    int gap=lenA-lenB;
    while (gap-->0){
        curA=curA.next;
    }
    //遍历剩下的链表，相同直接放回
    while (curA!=null){
        if (curA==curB){
            return curA;
        }
        curA=curA.next;
        curB=curB.next;
    }
    return null;
}

环形链表II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。

如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

输入：head = [3,2,0,-4], pos = 1

输出：返回索引为 1 的链表节点

解释：链表中有一个环，其尾部连接到第二个节点。

环形链表II

思路

这题是真一点思路都没得，看题解，感觉好奇妙

• 判断链表是否环
• 如果有环，如何找到这个环的入口

第一点：

可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。

为什么fast 走两个节点，slow走一个节点，有环的话，一定会在环内相遇呢，而不是永远的错开呢

首先第一点：fast指针一定先进入环中，如果fast指针和slow指针相遇的话，一定是在环中相遇，这是毋庸置疑的。

那么来看一下，为什么fast指针和slow指针一定会相遇呢？

可以画一个环，然后让 fast指针在任意一个节点开始追赶slow指针。

fast和slow各自再走一步， fast和slow就相遇了

这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合

第二点：

假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

代码

public static ListNode detectCycle(ListNode head) {
    ListNode slow = head;
    ListNode fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (fast == slow) {//有环
            ListNode node1=fast;
            ListNode node2=head;
            while (node1!=node2){
                node1=node1.next;
                node2=node2.next;
            }
            return node1;
        }
    }
    return null;
}