刷力扣Day04 | 24. 两两交换链表中的节点、19. 删除链表的倒数第 N 个结点、面试题 02.07. 链表相交、142.环形链表

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

题目：24.两两交换链表中的节点 

学习：讲解 

思路：添加一个虚拟头结点，创建临时指针保存要用到的节点对象。

注意：while循环中，要先判断cur.next != null ,再判断 cur.next.next != null，否则可能会出现空指针的错误。

代码：

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;//创建一个虚拟头结点，便于移动指针
        ListNode cur = dummy;

        while(cur.next != null && cur.next.next != null){
            ListNode temp1 = cur.next;//临时指针
            ListNode temp2 = cur.next.next.next;//临时指针
            cur.next = temp1.next;
            cur.next.next = temp1;
            temp1.next = temp2;
            cur = cur.next.next;
            
        }
        return dummy.next;


    }
}

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

题目：19.删除链表的倒数第N个结点

学习：视频讲解 

 思路：先找到链表的倒数第N个结点，再进行删除操作。如何找倒数第N个结点？定义两个指针，快指针先向前N+1步，再让fast和slow指针一起向前移动，当fast指针移动到NULL时，这时slow指针到了要删结点的前一个节点。

注意：返回虚拟头结点的next，而不是返回head

代码：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0,head);
        ListNode fast = dummy;
        ListNode slow = dummy;

        for(int i = 0; i < n + 1; i++){
            if(fast != null){
                fast = fast.next;
            }else{
                return head;
            }
        }

        while(fast != null){
                fast = fast.next;
                slow = slow.next;
        }

        slow.next = slow.next.next;
        return dummy.next;


    }
}

三、面试题 02.07. 链表相交

力扣题目：力扣

 学习：讲解

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = 0;
        int lenB = 0;
        ListNode curA = headA;
        ListNode curB = headB;
        while(curA != null){
            lenA++;
            curA = curA.next;
        }
        while(curB != null){
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        int gap = lenA - lenB;
        if(gap < 0){
            int temp = lenA;
            lenA = lenB;
            lenB = temp;

            ListNode tempnode = curA;
            curA = curB;
            curB = tempnode;
        }

        gap = Math.abs(gap);
        while(gap-- > 0){
            curA = curA.next;
            //gap--;
        }

        while(curA != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;

        
    }
}

 四、142.环形链表

题目：142.环形链表

学习：视频 

思路：①首先判断题目是否有环：可以定义两个指针，一个快指针，一个慢指针，快指针每次走两步，慢指针每次走一步，如果快指针和慢指针能够相遇，那么说明链表中存在环形，否则不存在；②如果有环形存在，那么再判断环形的入口：这里需要数学公式，假定入口前的节点数为x，从入口到两指针相遇点的节点数为y，相遇点到入口点的节点数为z，如图：

 我们先分析慢指针，慢指针进入环中，相当于快指针一步一步地靠近慢指针，所以快指针一定会和慢指针相遇，慢指针刚进入环，和快指针的距离不到一圈，所以快指针在追赶的过程中只需要移动小于两圈，因此慢指针只需移动一圈，所以慢指针走过的节点数为x+y，快指针走过的节点数为x+y+n(y+z),快指针走的节点数是慢指针的两倍，可得x+y+n(y+z)=2(x+y)，则x = (n-1)(y+z)+z，这表明，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {// 有环
                ListNode index1 = fast;
                ListNode index2 = head;
                // 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}