代码随想录算法训练营Day4 | | 24. 两两交换链表中的节点 ,19.删除链表的倒数第N个节点 , 面试题 02.07. 链表相交，142.环形链表-优快云博客

class Solution {
    public ListNode swapPairs(ListNode head) {
        //设置虚拟头节点
        ListNode dummyNode = new ListNode(0);
        ListNode curr = dummyNode;
        dummyNode.next=head;
        //交换节点
        while(curr.next != null&&curr.next.next != null){
          ListNode node3 = curr.next.next.next;
          ListNode node1 = curr.next;
          curr.next = node1.next;
          node1.next.next = node1;
          node1.next = node3; 
          curr = node1;
        }
        return dummyNode.next;
    }
}

var swapPairs = function(head) {
const dummyHead = new ListNode(0,head);
let curr = dummyHead;
while(curr.next !== null&& curr.next.next !== null){
    const tmp = curr.next.next.next;
    const tmp1 = curr.next;
    curr.next = tmp1.next;
    tmp1.next.next = tmp1;
    tmp1.next = tmp;
    curr = tmp1;
}
return dummyHead.next;
};

这里要注意的是如果要交换节点那么起始节点一定是在交换的节点前一个节点才能交换

如图所示如果我们需要交换node1和node2，那么我们一定是在curr的位置才能做到。

首先我们需要保存node3的节点，然后保存node1的节点,

接着我们让curr的next指针指向node2,node2的next指针指向node1,

node1的next指针指向node3,最后更新curr指针为node1

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

题目

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

代码

JAVA

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode countSizeNode = head;
        int nodeSize = 0;

        // 计算链表长度 nodeSize
        while (countSizeNode != null) {
            countSizeNode = countSizeNode.next;
            nodeSize++;
        }


        // 循环 nodeSize-n 次
        ListNode curr = dummyHead;
        for (int i = 0; i < nodeSize - n; i++) {
            curr = curr.next;
        }

        curr.next = curr.next.next;
        return dummyHead.next;
    }
}

var removeNthFromEnd = function(head, n) {
    // 设置虚拟头节点
    const dummyHead = new ListNode(0,head);
    let listSize = 0;
    let countSizeNode = head;
    // 计算链表长度listSize
    while (countSizeNode != null){
        countSizeNode = countSizeNode.next;
        listSize++;
    }
    let currNode = dummyHead;
    // 遍历listSize-n次到删除节点的前一个节点
    for (let i = 0; i < listSize - n; i++){
        currNode = currNode.next;
    }
    currNode.next = currNode.next.next;
    return dummyHead.next;
};

先遍历出链表的长度nodeSize，然后再遍历nodeSize-n次到删除的节点的前一个节点，因为如果我们要删除节点的话一定要在删除节点的前一个节点操作。

LCR 023. 相交链表

题目

给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

代码

JAVA

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

var getIntersectionNode = function(headA, headB) {
    if (headA == null || headB == null) {
        return null;
    }
    let pA = headA, pB = headB;
    while (pA != pB) {
        pA = pA == null ? headB : pA.next;
        pB = pB == null ? headA : pB.next;
    }
    return pA;
};

如果headA和headB中有一个为空节点那么他们就没有相交节点

当headA和headB相交有两种情况：

1.当headA和headB的链表长度一样，中间存在一时刻相交

2.长度不一样，比如headA长度小于headB的长度，pA走到尽头时赋值为headB重新开始

当headA和headB不相交有两种情况：

1.当headA和headB的链表长度一样，各自走到尽头也没有相交

2.长度不一样，各自走完headA+headB长度和也没有相交节点

142.环形链表

题目

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

代码

JAVA

public class Solution {
    public ListNode detectCycle(ListNode head) {
        // 快慢指针
        ListNode fast = head, slow = head;
        // 先让快慢指针相遇
        while (true) {
            if (fast == null || fast.next == null ) 
                return null;
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) 
                break;
        }
        // 重置快指针
        fast = head;
        // 让快慢指针移动相同距离使得它们在起点相遇
        while (fast != slow) {
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }
}

var detectCycle = function(head) {
    // 快慢指针
    let fast = head, slow = head;
    // 先让快慢指针相遇
    while (true) {
        if (fast == null || fast.next == null) 
            return null;
        fast = fast.next.next;
        slow = slow.next;
        if (fast == slow) 
            break;
    }
    // 重置快指针
    fast = head;
    // 让快慢指针移动相同距离使得它们在起点相遇
    while (fast != slow) {
        fast = fast.next;
        slow = slow.next;
    }
    return fast;
};

我们分析相遇的情况，我们设置了快慢指针，快指针每次走两步，慢指针每次走一步，假设快指针和慢指针各自走了f和s步后相遇,因为快指针速度是慢指针的两倍，所以f=2s,又因为快指针比慢指针先进入环，所以我们可以列出f=s+nb,通过这两个等式我们可以得知f=2nb,s=nb,而从起点到环形入口这处再加上nb个环的距离是a+nb,当我们重置快指针为起点位置，让快慢指针速度一致时，经过a个距离就可以让快慢指针在环形入口相遇.

我们分析一下不相遇的情况，当快指针的next指针和next.next指针一方为空的时候都不可能存在环形。