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

（补卡）代码随想录算法训练营第三天

代码随想录
● 24. 两两交换链表中的节点
● 19.删除链表的倒数第N个节点
● 02.07. 链表相交
● 142.环形链表II

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

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

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

思路：设置虚拟头节点

注意：cur指向两个要交换位置的前一个的节点

public ListNode swapPairs(ListNode head) {
        ListNode dumyHead = new ListNode();
        ListNode cur = dumyHead;
        cur.next = head;
        ListNode temp = null;
        ListNode temp1= null;
        while (cur.next!=null && cur.next.next!=null){
            temp = cur.next;
            temp1 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = temp;
            temp.next = temp1;
            cur = cur.next.next;
        }

        return dumyHead.next;
    }

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

耶！ 终于自己一遍就写出来啦，因为之前做过的题，对解题思路就有印象，感谢卡哥
思路：找倒数第N个节点的前一个节点，让快指针先走N步，在和慢指针一起走

public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dumyHead = new ListNode();
        dumyHead.next = head;
        ListNode slaw = dumyHead;
        ListNode fast = dumyHead;
        while(n>0){
            fast = fast.next;
            n--;
        }
        while(fast.next!=null){
            fast = fast.next;
            slaw = slaw.next;
        }
        slaw.next = slaw.next.next;
        return dumyHead.next;
    }

面试题 02.07. 链表相交

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

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        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;
			
        if(lenB>lenA){
            int tempLen = lenA;
            lenA = lenB;
            lenB = tempLen;

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

142.环形链表II

1、判断链表是否有环

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

2、如果有环，如何找到这个环的入口

此时已经可以判断链表是否有环了，那么接下来要找这个环的入口了。
假设从头结点到环形入口节点 的节点数为x。 环形入口节点到 fast指针与slow指针相遇节点 节点数为y。 从相遇节点 再到环形入口节点节点数为 z。 如图所示：

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。
从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

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