新增4题，累积17题

Author: mercuriussss

src/com/cjl/common/ListNode.java

@@ -4,7 +4,12 @@
 public class ListNode {
     public int val;
     public ListNode next;
+    public ListNode() { }
     public ListNode(int x) {
-        val = x;
+        this.val = x;
+    }
+    public ListNode(int x, ListNode next) {
+        this.val = x;
+        this.next = next;
     }
 }

src/com/cjl/leetcode/Question_143.java

@@ -0,0 +1,81 @@
+package com.cjl.leetcode;
+
+import com.cjl.common.ListNode;
+
+import java.util.Deque;
+
+/*
+    143. 重排链表
+    问题描述：
+        给定一个单链表 L 的头节点 head ，单链表 L 表示为：
+        L0→ L1→ … → Ln-1→ Ln
+        请将其重新排列后变为：
+        L0→Ln→L1→Ln-1→L2→Ln-2→ …
+        不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
+    示例 1:
+        输入: head = [1,2,3,4]
+        输出: [1,4,2,3]
+    示例 2:
+        输入: head = [1,2,3,4,5]
+        输出: [1,5,2,4,3]
+    提示：
+        链表的长度范围为 [1, 5 * 10^4]
+        1 <= node.val <= 1000
+ */
+public class Question_143 {
+
+    // 时间复杂度是O(N)，空间复杂度是O(1)
+    public void solution1(ListNode head) {
+        if(head == null){
+            return;
+        }
+        // 获得中间节点
+        ListNode mid = findMid(head);
+
+        // 中间节点之后的部分进行反转
+        ListNode head2 = mid.next;
+        // 切割链表，分成前后两部分
+        mid.next = null;
+        head2 = reverseList(head2);
+
+        // 合并
+        mergeList(head,head2);
+    }
+
+    private ListNode findMid(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast.next != null && fast.next.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return slow;
+    }
+
+    private ListNode reverseList(ListNode head) {
+        ListNode pre = null;
+        ListNode cur = head;
+        while(cur != null){
+            ListNode tmp = cur.next;
+            cur.next = pre;
+            pre = cur;
+            cur = tmp;
+        }
+        return pre;
+    }
+
+    private void mergeList(ListNode head1, ListNode head2) {
+        ListNode next1 = null;
+        ListNode next2 = null;
+        while(head1 != null && head2 != null) {
+            next1 = head1.next;
+            next2 = head2.next;
+
+            head1.next = head2;
+            head1 = next1;
+
+            head2.next = head1;
+            head2 = next2;
+        }
+    }
+}

src/com/cjl/leetcode/Question_440.java

@@ -0,0 +1,50 @@
+package com.cjl.leetcode;
+
+/*
+    440. 字典序的第K小数字
+    问题描述：
+        给定整数 n 和 k，找到 1 到 n 中字典序第 k 小的数字。
+    注意：
+        1 ≤ k ≤ n ≤ 10^9。
+    示例：
+        输入:n: 13   k: 2
+        输出:10
+        解释:字典序的排列是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]，所以第二小的数字是 10。
+ */
+public class Question_440 {
+
+    // 时间复杂度是O(k)，空间复杂度是O(1)
+    public int solution1(int n, int k) {
+        int cur = 1;
+        k = k - 1;
+        while(k > 0) {
+            int num = getCount(n, cur, cur + 1);
+            if(num <= k) {
+                // 若第k个数不在以cur为根节点的树上，则往右移动到兄弟节点
+                cur += 1;
+                k -= num;
+            }else{
+                // 第k个数在以cur为根节点的树上，往子节点移动
+                cur *= 10;
+                k -= 1;
+            }
+        }
+        return cur;
+    }
+
+    private int getCount(int n, int first, int last){
+        int num = 0;
+        while(first <= n) {
+            // 比如n是195的情况195到100有96个数
+            num += Math.min(n+1, last) - first;
+            // 防止溢出
+            if(first <= n / 10){
+                first *= 10;
+                last *= 10;
+            } else {
+                break;
+            }
+        }
+        return num;
+    }
+}

src/com/cjl/leetcode/Question_56.java

@@ -0,0 +1,51 @@
+package com.cjl.leetcode;
+
+import java.util.*;
+
+/*
+    56. 合并区间
+    以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。
+    请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
+    示例 1：
+        输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
+        输出：[[1,6],[8,10],[15,18]]
+        解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
+    示例2：
+        输入：intervals = [[1,4],[4,5]]
+        输出：[[1,5]]
+        解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
+    提示：
+        1 <= intervals.length <= 10^4
+        intervals[i].length == 2
+        0 <= starti <= endi <= 10^4
+ */
+public class Question_56 {
+
+    public int[][] solution1(int[][] intervals) {
+        if(intervals == null || intervals.length == 1){
+            return intervals;
+        }
+        List<Integer> arr = new ArrayList<>();
+        // 按最小界排序
+        Arrays.sort(intervals, Comparator.comparingInt(a -> a[0]));
+        // 记录前面的最大界
+        int preEnd = -1;
+        for (int[] interval : intervals) {
+            if (interval[0] > preEnd) {
+                // 当前最小界大于前面的最大界，不能合并
+                arr.add(interval[0]);
+                arr.add(interval[1]);
+            }else if (interval[1] > preEnd){
+                // 当前最小界小于或等于前面的最大界，并且当前最大界大于前面的最大界，可合并
+                arr.remove(arr.size() - 1);
+                arr.add(interval[1]);
+            }
+            preEnd = Math.max(preEnd,interval[1]);
+        }
+        int[][] res = new int[arr.size()/2][2];
+        for (int i = 0; i < arr.size(); i++) {
+            res[i/2][i%2] = arr.get(i);
+        }
+        return res;
+    }
+}

src/com/cjl/leetcode/Question_7.java

@@ -0,0 +1,44 @@
+package com.cjl.leetcode;
+
+/*
+    7. 整数反转
+    问题描述：
+        给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
+        如果反转后整数超过 32 位的有符号整数的范围[−2^31, 2^31− 1] ，就返回 0。
+        假设环境不允许存储 64 位整数（有符号或无符号）。
+    示例 1：
+        输入：x = 123
+        输出：321
+    示例 2：
+        输入：x = -123
+        输出：-321
+    示例 3：
+        输入：x = 120
+        输出：21
+    示例 4：
+        输入：x = 0
+        输出：0
+    提示：
+        -2^31 <= x <= 2^31 - 1
+ */
+public class Question_7 {
+
+    // 时间复杂度是O(1)，空间复杂度是O(1)
+    public static int solution1(int x){
+        boolean flag = x > 0;
+        if(!flag && Math.abs(x) >= Integer.MAX_VALUE) {
+            return 0;
+        }
+        int res = 0;
+        int temp = Math.abs(x);
+        while(temp != 0) {
+            if(res > (Integer.MAX_VALUE - temp % 10)/10){
+                return 0;
+            }else{
+                res = res * 10 + temp % 10;
+                temp /= 10;
+            }
+        }
+        return flag ? res: -res;
+    }
+}