代码随想录算法训练营第四天|24.两两交换链表中的节点、19.删除链表的倒数第N个节点、02.07.链表相交、142.环形链表||

代码随想录算法训练营第四天|24.两两交换链表中的节点、19.删除链表的倒数第N个节点、02.07.链表相交、142.环形链表||

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

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

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

题解：交换用到三个节点。注意谁是后缀节点。

代码：

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dammyhead=new ListNode(0,head);
        ListNode curr=dammyhead;
        while(curr.next!=null && curr.next.next!=null){
            ListNode temp1=curr.next;
            ListNode temp2=curr.next.next;
            curr.next=temp2;
            temp1.next=temp2.next;
            temp2.next=temp1;
            curr=curr.next.next;
        }
        return dammyhead.next;
    }
}

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

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

示例 1：

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

题解：计算一下倒数第N个节点正这走需要几步。

代码：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //先计算链表大小
        ListNode curr=head;
        int size=0;
        while(curr!=null){
            size++;
            curr=curr.next;
        }
        ListNode dammyhead=new ListNode(0,head);
        ListNode node=dammyhead;
        for(int i=0;i<size-n;i++){
            node=node.next;
        }
        node.next=node.next.next;
        return dammyhead.next;
    }
}

02.07.链表相交

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

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

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

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

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

题解：先将两条链表变成一样长，然后同时开始走直到两条链表的节点相同。

代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curr1=headA;
        ListNode curr2=headB;
        int len1=0,len2=0;
        while(curr1!=null) {
            len1++;
            curr1=curr1.next;
        }
        while(curr2!=null) {
            len2++;
            curr2=curr2.next;
        }
        
        //让链表1是长链表
        if(len1<len2){
            ListNode temp=headB;
            headB=headA;
            headA=temp;
        }
        curr1=headA;
        curr2=headB;
        int gap;
        if(len1>len2){
            gap=len1-len2;
        }else{
            gap=len2-len1;
        }
        for(int i=0;i<gap;i++){
            curr1=curr1.next;
        }
        while(curr1!=null && curr2!=null){
            if(curr1==curr2) return curr1;
            curr1=curr1.next;
            curr2=curr2.next;
        }
        return null;
    }
}

142.环形链表||

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

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

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

题解：双指针解法。快指针两步一走，慢指针一步一走，如果二者能相交，说明有环。找到环起始位置方法：定义一个指针从开始出发，和慢指针一起走，相交的位置是环的其实位置。

循环条件是什么？：因为fast两步一走，判断fast!=null && fase.next!=null

代码：

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