新增2题，累积21题

Author: mercuriussss

src/com/cjl/leetcode/Question_23.java

@@ -0,0 +1,64 @@
+package com.cjl.leetcode;
+
+import com.cjl.common.ListNode;
+
+import java.util.*;
+
+/*
+    23. 合并K个升序链表
+    问题描述：
+        给你一个链表数组，每个链表都已经按升序排列。
+        请你将所有链表合并到一个升序链表中，返回合并后的链表。
+    示例 1：
+        输入：lists = [[1,4,5],[1,3,4],[2,6]]
+        输出：[1,1,2,3,4,4,5,6]
+        解释：链表数组如下：
+        [
+          1->4->5,
+          1->3->4,
+          2->6
+        ]
+        将它们合并到一个有序链表中得到。
+        1->1->2->3->4->4->5->6
+    示例 2：
+        输入：lists = []
+        输出：[]
+    示例 3：
+        输入：lists = [[]]
+        输出：[]
+    提示：
+        k == lists.length
+        0 <= k <= 10^4
+        0 <= lists[i].length <= 500
+        -10^4 <= lists[i][j] <= 10^4
+        lists[i] 按 升序 排列
+        lists[i].length 的总和不超过 10^4
+ */
+public class Question_23 {
+
+    // 时间复杂度是O(NlogK)，空间复杂度是O(K)，K为队列中的元素数量
+    public ListNode solution1(ListNode[] lists) {
+        if(lists == null || lists.length == 0) {
+            return null;
+        }
+        Queue<ListNode> pq = new PriorityQueue<>(Comparator.comparingInt(v -> v.val));
+        for (ListNode list : lists) {
+            // 添加集合中的链表
+            if(list != null) {
+                pq.offer(list);
+            }
+        }
+        ListNode head = new ListNode(0);
+        ListNode cur = head;
+        while(!pq.isEmpty()) {
+            ListNode tmp = pq.poll();
+            cur.next = tmp;
+            cur = cur.next;
+            if(tmp.next != null){
+                // 将当前的链表节点往后移
+                pq.offer(tmp.next);
+            }
+        }
+        return head.next;
+    }
+}

src/com/cjl/leetcode/Question_46.java

@@ -0,0 +1,53 @@
+package com.cjl.leetcode;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/*
+    46. 全排列
+    问题描述：
+        给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
+    示例 1：
+        输入：nums = [1,2,3]
+        输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+    示例 2：
+        输入：nums = [0,1]
+        输出：[[0,1],[1,0]]
+    示例 3：
+        输入：nums = [1]
+        输出：[[1]]
+    提示：
+        1 <= nums.length <= 6
+        -10 <= nums[i] <= 10
+        nums 中的所有整数 互不相同
+ */
+public class Question_46 {
+
+    // 时间复杂度是O(N)，空间复杂度是O(N)
+    public List<List<Integer>> solution1(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (nums.length == 0) {
+            return res;
+        }
+        recur(nums, new ArrayList<>(), res);
+        return res;
+    }
+
+    private void recur(int[] nums, List<Integer> target, List<List<Integer>> res) {
+        if (target.size() == nums.length) {
+            res.add(new ArrayList<>(target));
+            return;
+        }
+        for (int cur : nums) {
+            if (target.contains(cur)) {
+                continue;
+            }
+            target.add(cur);
+            recur(nums, target, res);
+            target.remove(target.size() - 1);
+        }
+    }
+}

src/com/cjl/leetcode/Question_56.java

@@ -23,7 +23,7 @@
 public class Question_56 {
 
     public int[][] solution1(int[][] intervals) {
-        if(intervals == null || intervals.length == 1){
+        if (intervals == null || intervals.length == 1) {
             return intervals;
         }
         List<Integer> arr = new ArrayList<>();
@@ -36,16 +36,16 @@ public int[][] solution1(int[][] intervals) {
                 // 当前最小界大于前面的最大界，不能合并
                 arr.add(interval[0]);
                 arr.add(interval[1]);
-            }else if (interval[1] > preEnd){
+            } else if (interval[1] > preEnd) {
                 // 当前最小界小于或等于前面的最大界，并且当前最大界大于前面的最大界，可合并
                 arr.remove(arr.size() - 1);
                 arr.add(interval[1]);
             }
-            preEnd = Math.max(preEnd,interval[1]);
+            preEnd = Math.max(preEnd, interval[1]);
         }
-        int[][] res = new int[arr.size()/2][2];
+        int[][] res = new int[arr.size() / 2][2];
         for (int i = 0; i < arr.size(); i++) {
-            res[i/2][i%2] = arr.get(i);
+            res[i / 2][i % 2] = arr.get(i);
         }
         return res;
     }