代码随想录 day4 第二章 链表part02

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

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

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
注意是每隔两个交换一次，因此操作应当以两个节点为单位。
自己想确实很混乱，但是看解析一看就懂。
用了虚拟头节点cur，还用了另外三个节点引用保存cur.next, cur.next.next和cur.next.next.next. 用缓存的原因是可以防止超时。

迭代版本：

class Solution {
    public ListNode swapPairs(ListNode head) {
        //iteration
        ListNode newhead = new ListNode(-1, head);
        ListNode cur = newhead;
        while(cur.next != null && cur.next.next != null)
        {
	        //注意超时
            ListNode temp = cur.next.next.next;
            ListNode before = cur.next;
            ListNode after = cur.next.next;
            //三个引用缓存三个节点
            cur.next = after;
            after.next = before;
            before.next = temp;

            cur = cur.next.next;//cur向后移动两个节点，开始下一次循环
        }
        return newhead.next;
    }
}

递归版本：

public ListNode swapPairs(ListNode head){  
	//recursion
	if(head == null || head.next == null)
	{
		return head;
	}
	ListNode nextnode = head.next;
	//recursion here
	ListNode newnode = swapPairs(nextnode.next);
	//swap here
	nextnode.next = head;
	head.next = newnode;
	return nextnode;
}

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

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

这次使用的方法是从前向后遍历，但是用双指针的滑动窗口，滑动窗口大小为n.
原因是如果窗口右端到达终点，那么左端必然会到达节点应当删除的位置
(这时候慢指针会指向删除节点的上一个节点，正好可以跳过该删除节点)

同样，本题还是使用虚拟头节点以省去一些判定的麻烦。

public ListNode removeNthFromEnd(ListNode head, int n) {
	ListNode newhead = new ListNode(-1, head);
	ListNode slow = newhead;
	ListNode fast = head;
	//先走n步,如果fast和slow从同一位置出发，则是n+1步,总之保证slow最后到达删除节点的前一个节点位置
	for(int i=0; i<n; i++)
	{
		fast = fast.next;
	}
	//一块走
	while(fast != null)
	{
		fast = fast.next;
		slow = slow.next;
	}
	ListNode slowafter = slow.next.next;
	slow.next = slowafter;
	
	return newhead.next;
}

注意前面的快指针临界条件是指向空节点，所以是fast != null不是fast.next != null。
重点是保证slow最后到达删除节点的前一个节点位置，先让快指针移动拉开窗口差距，再快慢同时移动。

在群里看到，非常赞同这句话：
滑动窗口本质上还是双指针，一左一右两个指针圈定一个窗口，指针在移动，窗口就在滑动。
对于数组这个数据结构来说，双指针是重点，但同样这种思想也可以用在链表上。

题目三 面试题 02.07. 链表相交

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

本题关键：数值相同，不代表指针相同。

本题其中的一个关键在于:首先需要遍历得出两个链表的长度，之后需要回到开头重新开始遍历，让指针到达合适的位置。这时候不能直接移动所给的两个头节点，不然没法回去。
因此需要先将两个头节点拷贝之后再遍历，遍历过后拷贝值再赋值为头节点，这样就能重复循环。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int heada = 0;
        int headb = 0;
        ListNode curA = headA;
        ListNode curB = headB;
        while(curA != null)
        {
            curA = curA.next;
            heada++;
        }
        while(curB != null)
        {
            curB = curB.next;
            headb++;
        }

        //复位
        curA = headA;
        curB = headB;
        
        int num = 0;
        if(heada >= headb)
        {
            num = heada - headb;
            //长的先挪
            for(int i=0; i<num; i++)
            {
                curA = curA.next;
            }
            while(curA != null )
            {  
                if(curA == curB)
                {
                    return curA;
                }
                //一块挪
                curA = curA.next;
                curB = curB.next;
            }return null;
            
        }else if(heada < headb)
        {
            num = headb - heada;
            //长的先挪
            for(int i=0; i<num; i++)
            {
                curB = curB.next;
            }
            
            while( curB != null)
            {  
                if(curA == curB)
                {
                    return curB;
                }
                //一块挪
                curA = curA.next;
                curB = curB.next;
            }return null;
        }
        return null;
    }
}

上面是自己写的，还是过于啰嗦了。和给出的参考答案思路差不多.
首先遍历两个链表得到长度，然后复位，之后使得长链表指针挪到和短链表一样的长度位置，再同时向后遍历，如果两者指向的节点完全相同，那就可以证明这是个分支节点。(后面的节点不用看了，从这里开始后面的必定相同)

不过后者的高明之处在于提前使用交换保证链表a始终长于链表b，这样可以避免代码的重复。

// 让curA为最长链表的头，lenA为其长度
if (lenB > lenA) {
	//1. swap (lenA, lenB);
	int tmpLen = lenA;
	lenA = lenB;
	lenB = tmpLen;
	//2. swap (curA, curB);
	ListNode tmpNode = curA;
	curA = curB;
	curB = tmpNode;
}

题目四 142.环形链表II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。

这道题自己想完全没思路，不过给的解析非常明朗，一看就懂。
本题关键在如何判断环的存在以及定位第一次入环的位置。

同样可用快慢指针来判断环的存在。令快指针速度快于慢指针，然后两者同时追击移动，如果不存在环，慢指针就永远追不上快的；如果有环，那么多次绕圈之后，两个指针一定能相遇。
比如快指针一次移动两个节点，慢指针一次只移动一个。

那么如何推断第一次入环的位置呢？这相当于一个环形追击问题，因此需要理清相遇位置和环形入口位置的数学关系。

经过解析给出的数学推断我们得出：从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是环形入口的节点。

当然，前提是快指针走两步，满指针走一步，其他情况条件会失效。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。
让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是环形入口的节点。
也就是只要找到相遇节点，我们就能推出入口节点。
n如果大于1，就是fast指针在环形转n圈之后才遇到 slow指针。其实这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过，index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

注意上面的前提也帮我们省去了一个麻烦：快指针走两圈，慢指针恰好走一圈。
因此，慢指针会在走不完一圈的情况下就会与快指针相遇，而不是走好几圈。

为什么fast不能跳过去呢？ 在刚刚已经说过一次了，fast相对于slow是一次移动一个节点，所以不可能跳过去。

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