day4 链表part2

tips

代码中还用到一个链表的算法题中是很常见的「虚拟头结点」技巧，也就是 dummy 节点。你可以试试，如果不使用 dummy 虚拟节点，代码会复杂一些，需要额外处理指针 p 为空的情况。而有了 dummy 节点这个占位符，可以避免处理空指针的情况，降低代码的复杂性。

labuladong：什么时候需要用虚拟头结点？我这里总结下：当你需要创造一条新链表的时候，可以使用虚拟头结点简化边界情况的处理。
比如说，让你把两条有序链表合并成一条新的有序链表，是不是要创造一条新链表？再比你想把一条链表分解成两条链表，是不是也在创造新链表？这些情况都可以使用虚拟头结点简化边界情况的处理。

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

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

 //递归方法
class Solution {
    public ListNode swapPairs(ListNode head) {
        //边缘情况
        if (head == null || head.next == null){
            return head;
        }

        ListNode first = new ListNode(); //临时节点，用于保存第一个节点
        ListNode secend = new ListNode();//临时节点，用于保存第二个节点
        ListNode others = new ListNode();//用于保存之后的节点

        first = head;
        secend = head.next;
        others = head.next.next;

        //开始反转前两个节点
        secend.next = first; //做递归可以从最简单的空链表，一个节点，两个节点开始思考，这里是在做这个迭代该做的事，swapPairs
        //swapPair(others)只负责做以后的交换，当前的交换要在当前做
        

        //利用递归将剩下的节点两两反转，接到后面
        first.next = swapPairs(others);

        return secend; //这里写的时候没搞明白，看答案恍然大悟
        }

}

迭代方法，什么时候需要使用虚拟头结点？

 //迭代方法
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode cur = dummy; //临时节点不用开辟空间！！！
        ListNode temp; // 临时节点，保存两个节点后面的节点
        ListNode first; // 临时节点，保存两个节点之中的第一个节点
        ListNode secend; // 临时节点，保存两个节点之中的第二个节点

        while (cur.next != null && cur.next.next != null) {
            first = cur.next;
            secend = cur.next.next;
            temp = cur.next.next.next;

            secend.next = first;
            first.next = temp; //这两步交换节点
            cur.next = secend; //记得要把虚拟头结点指向secend


            cur = first; //cur移动，准备交换下两个节点
        }

        return dummy.next;
    }
}

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

中等
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点
（自己注：这种一般不会给你一个空指针的，实在不行可以判断一下是不是null）

难点1：没想到要用双指针

双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

难点2：虚拟头结点

使用了虚拟头结点的技巧，也是为了防止出现空指针的情况，比如说链表总共有 5 个节点，题目就让你删除倒数第 5 个节点，也就是第一个节点，那按照算法逻辑，应该断开前一个节点到第一个节点之间的连接。但第一个节点前面已经没有节点了，这就会出错。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(); 
        dummy.next = head;
        ListNode first = dummy; //first 就是快的那个指针
        ListNode second = dummy; //secend 就是慢的那个指针

        for (int i = 0; i < n; i++){
            first = first.next;
        }
        while (first.next != null){
            first = first.next;
            second = second.next;
        }
        second.next = second.next.next;

        return dummy.next;
    }
}

面试题 02.07. 链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。题目数据 保证 整个链式结构中不存在环。

//暴力法
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a = headA;
        
        while (a != null){
            ListNode b = headB;
            while (b != null){
                if (a == b){
                    return a;
                }
                b = b.next;
            }
            a = a.next;
        }

        return null;
    }
}

相当于这样一个带拉链的布条，如果要找到布条是从哪里有拉链接合的，就应该让它们底端对齐，然后开始找。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
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) { // 求链表A的长度
            lenA++;
            curA = curA.next;
        }

        while (curB != null) { // 求链表B的长度
            lenB++;
            curB = curB.next;
        }

        curA = headA;
        curB = headB;

        //让A 变成较长的那条链表
        if (lenA >= lenB){
        }else{
            int temp = lenA;
            lenA = lenB;
            lenB = temp;

            curA = headB;
            curB = headA;
        }

        // 求长度差
        int gap = lenA - lenB;
        for (int i = 0; i < gap; i++){
            curA = curA.next;
        }
        while (curA != null){ //这里不是while (curA.next != null)！！！因为可能有这种情况：A[1,2,3]  B[3], 这样最后一个节点无法判断
            if (curA == curB){
                return curA;
            }else{
                curA = curA.next;
                curB = curB.next;
            }
        }

        return null;
    }
}

142. 环形链表 II

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

难点：这题比较难，没有思路、

我个人有个思路，不知可不可行，实在没时间实现了。先判断有没有环，如果有环，那么我们就能用快慢指针找到环内一个相遇节点。从头结点，到环转一圈全部的节点数量n就可以知道，再以相遇节点转一圈，知道环的节点数量m，用m-n 就能知道那里是入环点。

引用了这位佬的分析：http://t.csdnimg.cn/V9xOu
使用快慢指针法。定义一个慢指针slow和一个快指针fast，slow每次走一步，fast每次走两步，直到fast为空或者fast->next为空为止。如果链表中存在环，则在某一时刻fast一定会追上slow。所以在循环过程中，如果slow和fast相等则链表中存在环；如果直到循环结束slow和fast都不等则链表中不存在环。
思考：为什么slow走1步，fast走2步时，slow和fast一定会相遇呢？如果slow走1步，fast走3步，slow和fast一定会相遇吗？

第一个问题，如果链表有环，slow走1步，fast走2步时，fast比slow先进环。假设当slow进环时，fast与slow的距离为N。slow进环后，fast开始追赶slow，slow每走1步、fast每走2步，slow和fast之间的距离减少1步。在整个追赶过程中，slow和fast之间的距离变化为：N、N-1、N-2、……3、2、1、0，所以slow和fast一定会相遇。
第二个问题，如果链表有环，slow走1步，fast走3步时，fast比slow先进环。假设当slow进环时，fast与slow的距离为N。slow进环后，fast开始追赶slow，slow每走1步、fast每走3步，fast和slow之间的距离减少2步。在整个追赶过程中，当N为偶数时，slow和fast之间的距离变化为：N、N-2、N-4、……4、2、0，slow和fast一定会相遇；当N为奇数时，fast和slow之间的距离变化为：N、N-2、N-4……3、1、-1，此时fast开始新一轮的追赶。假设环的长度为C，此时fast与slow的距离为C-1，如果C-1为偶数，slow和fast一定会相遇；如果C-1为奇数，slow和fast永远不会相遇。所以slow走1步，fast走3步时，slow和fast不一定会相遇。

在判环时，慢指针slow走的路径长度为L+X，快指针fast走的路径长度为L+nC+X(n>=1)。而fast所走路径长度是slow所走路径长度的2倍，即L+nC+X=2*（L+X），展开得L= nC-X，也就是L=（n-1）C+C-X。即一个指针从head开始走，一个指针从meet开始走，这两个指针一定会在环起始结点相遇。
这里的意思是，两个指针都要速度为一，因为L=（n-1）C+C-X，而从meet走head’，需要C-X，从head走到head’ 需要（n-1）C+C-X，两者相差整圈数量，所以能在head’遇到。下面是这种解法，
纯粹数学题。

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

然后今天是有链表相交的题目的。