3、链表（下）

6、反转链表

反转一个单链表。

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        while (head != null) {
            ListNode next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }
}

7、反转链表 II

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        if (m == n) return head;
        //由于在本题中head节点有可能发生变化当m=1时，所以需要一个dummy节点
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode begin = dummy;
        //begin节点为m节点前面的节点
        ListNode cur = head;
        for (int i = 0; i < m - 1; i++) {
            begin = begin.next;
            cur = cur.next;
        }
        ListNode pre = cur, end = cur;
        //pre和end此时都指向m节点，end指m节点，为了后面m节点指向n后面的节点
        cur = cur.next;
        for (int j = 0; j < n - m; j++) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        //m前面的节点指向n
        begin.next = pre;
        //m节点指向n后面的节点
        end.next = cur;
        return dummy.next;
    }
}

8、相交链表

编写一个程序，找到两个单链表相交的起始节点。

/**
 * 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) {
        ListNode p = headA, q = headB;
        while (p != q) {
            p = p == null ? headB : p.next;
            q = q == null ? headA : q.next;
        }
        return p;
        //如果没有交点，p == q == null返回
    }
}

9、环形链表II

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

说明：不允许修改给定的链表。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        //快慢指针
        ListNode fast = head, slow = head;
        while (slow != null) {
            slow = slow.next;
            fast = fast.next;
            if (fast != null && fast.next != null) fast = fast.next;
            else break;
            //fast == null || fast.next == null，说明该链表没有环
            if (fast == slow) {
                //相遇在m点
                slow = head;
                while (slow != fast) {
                    slow = slow.next;
                    fast = fast.next;
                }
                return slow;
            }
        }
        return null;
    }
}

10、排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

在递归时会用到O（logn）的空间复杂度，所以我们要使用自底向上的归并排序，迭代版。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        //由于head节点可能会变，所以需要一个虚拟头节点
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode cur = dummy;
        int n = 0;
        while (cur.next != null) {
            n++;
            cur = cur.next;
        }
        for (int i = 1; i < n; i *= 2) {
            //每轮归并的宽度，第一次1，第二次2，直到i == n时代表归并完毕，归并logn次
            cur = dummy;
            for (int j = 0; j + i < n; j += i * 2) {
                ListNode left = cur.next, right = left;
                for (int k = 0; k < i; k++) right = right.next;
                int l = 0, r = 0;
                while (l < i && r < i && right != null) {
                    if (left.val <= right.val) {
                        cur.next = left;
                        cur = left;
                        left = left.next;
                        l++;
                    } else {
                        cur.next = right;
                        cur = right;
                        right = right.next;
                        r++;
                    }
                }
                while (l < i) {
                    cur.next = left;
                    cur = left;
                    left = left.next;
                    l++;
                }
                while (r < i && right != null) {
                    cur.next = right;
                    cur = right;
                    right = right.next;
                    r++;
                }
                //由于之前的right = right.next，所以
                cur.next = right;
                //cur指向right的下一个节点
            }
        }
        return dummy.next;
    }
}

最难点应该在于j + i < n的理解。

1-2-3-4-5

1、第一次归并时，i = 1，1，2，3， 4，5各一组。

j从0，变为2，变为4，当j = 4时，j + i = 5 == n，所以当left存在而right不存在时，放弃这次合并。

2、第二次归并时，i = 2，12一组和34一组进行归并，5一组。

j从0，变为4，j + i = 6 > n，所以在第二轮5依旧不参与归并。

3、第三次归并时，i = 4，1234一组和5一组进行归并。

当j = 0时，j + i = 4 < n，所以5是参与归并的。

结论：

在找right部分时，如果right部分不存在，则放弃此次归并；如果right部分存在，但是长度小于i，则也要归并。