update

Author: yupeng10

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "java.debug.settings.onBuildFailureProceed": true
+}

src/main/java/leetcode/editor/cn/P146LruCache.java

@@ -0,0 +1,161 @@
+//
+// 请你设计并实现一个满足 
+// LRU (最近最少使用) 缓存 约束的数据结构。
+// 
+//
+// 
+// 实现 
+// LRUCache 类：
+// 
+//
+// 
+// 
+// 
+// LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 
+// int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 
+// void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 
+//key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。 
+// 
+// 
+// 
+//
+// 函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。 
+//
+// 
+//
+// 示例： 
+//
+// 
+//输入
+//["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
+//[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+//输出
+//[null, null, null, 1, null, -1, null, -1, 3, 4]
+//
+//解释
+//LRUCache lRUCache = new LRUCache(2);
+//lRUCache.put(1, 1); // 缓存是 {1=1}
+//lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
+//lRUCache.get(1);    // 返回 1
+//lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
+//lRUCache.get(2);    // 返回 -1 (未找到)
+//lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
+//lRUCache.get(1);    // 返回 -1 (未找到)
+//lRUCache.get(3);    // 返回 3
+//lRUCache.get(4);    // 返回 4
+// 
+//
+// 
+//
+// 提示： 
+//
+// 
+// 1 <= capacity <= 3000 
+// 0 <= key <= 10000 
+// 0 <= value <= 10⁵ 
+// 最多调用 2 * 10⁵ 次 get 和 put 
+// 
+//
+// Related Topics 设计 哈希表 链表 双向链表 👍 3335 👎 0
+
+
+package leetcode.editor.cn;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class P146LruCache {
+    public static void main(String[] args) {
+    }
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class LRUCache {
+
+        class DLinkedNode {
+            int key;
+            int value;
+            DLinkedNode next;
+            DLinkedNode prev;
+        }
+
+        int size;
+        int capacity;
+        DLinkedNode head;
+        DLinkedNode tail;
+        Map<Integer, DLinkedNode> cache = new HashMap<>();
+
+        public LRUCache(int capacity) {
+            this.capacity = capacity;
+            this.size = 0;
+            this.head = new DLinkedNode();
+            this.tail = new DLinkedNode();
+            head.next = tail;
+            tail.prev = head;
+        }
+
+        public int get(int key) {
+            DLinkedNode node = cache.get(key);
+            if (node == null) {
+                return -1;
+            }
+            moveToHead(node);
+            return node.value;
+        }
+
+
+        public void put(int key, int value) {
+
+            DLinkedNode node = cache.get(key);
+            if (node == null) {
+                DLinkedNode newNode = new DLinkedNode();
+                newNode.key = key;
+                newNode.value = value;
+                cache.put(key, newNode);
+                addToHead(newNode);
+                size++;
+                if (size > capacity) {
+                    cache.remove(removeTail().key);
+                    size--;
+                }
+            }else {
+                node.value = value;
+                moveToHead(node);
+            }
+
+        }
+
+        private DLinkedNode removeTail() {
+
+            DLinkedNode node = tail.prev;
+            tail.prev = node.prev;
+            node.prev.next = tail;
+            return node;
+        }
+
+        private void moveToHead(DLinkedNode node) {
+            removeNode(node);
+            addToHead(node);
+        }
+
+        private void addToHead(DLinkedNode node) {
+            node.next = head.next;
+            node.prev = head;
+            head.next.prev = node;
+            head.next = node;
+        }
+
+        private void removeNode(DLinkedNode node) {
+            node.prev.next = node.next;
+            node.next.prev = node.prev;
+        }
+    }
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * LRUCache obj = new LRUCache(capacity);
+ * int param_1 = obj.get(key);
+ * obj.put(key,value);
+ */
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/P23MergeKSortedLists.java

@@ -0,0 +1,124 @@
+//给你一个链表数组，每个链表都已经按升序排列。
+//
+// 请你将所有链表合并到一个升序链表中，返回合并后的链表。 
+//
+// 
+//
+// 示例 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 
+// 
+//
+// Related Topics 链表 分治 堆（优先队列） 归并排序 👍 2925 👎 0
+
+
+package leetcode.editor.cn;
+
+public class P23MergeKSortedLists {
+    public static void main(String[] args) {
+        Solution solution = new P23MergeKSortedLists().new Solution();
+        //[[1,4,5],[1,3,4],[2,6]]
+        //生成测试用例
+        ListNode l1 = new ListNode(1);
+        ListNode l2 = new ListNode(4);
+        ListNode l3 = new ListNode(5);
+        l1.next = l2;
+        l2.next = l3;
+        ListNode l4 = new ListNode(1);
+        ListNode l5 = new ListNode(3);
+        ListNode l6 = new ListNode(4);
+        l4.next = l5;
+        l5.next = l6;
+        ListNode l7 = new ListNode(2);
+        ListNode l8 = new ListNode(6);
+        l7.next = l8;
+        ListNode[] lists = new ListNode[]{l1, l4, l7};
+        solution.mergeKLists(lists);
+    }
+    //leetcode submit region begin(Prohibit modification and deletion)
+
+    /**
+     * Definition for singly-linked list.
+     * public class ListNode {
+     * int val;
+     * ListNode next;
+     * ListNode() {}
+     * ListNode(int val) { this.val = val; }
+     * ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+     * }
+     */
+    class Solution {
+        public ListNode mergeKLists(ListNode[] lists) {
+            return merge(lists, 0, lists.length-1);
+        }
+
+        public ListNode merge(ListNode[] lists, int l, int r) {
+            if (l == r) {
+                return lists[l];
+            }
+            if (l > r) {
+                return null;
+            }
+            int mid = (l+r) >> 1;
+            return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
+        }
+
+        public ListNode mergeTwoLists(ListNode head1, ListNode head2) {
+            if(head1 == null || head2 == null) return head1 == null ? head2 : head1;
+            ListNode dummy = new ListNode(0);
+            ListNode temp = dummy, temp1 = head1, temp2 = head2;
+            while (temp1 != null && temp2 != null) {
+                if (temp1.val < temp2.val) {
+                    temp.next = temp1;
+                    temp1 = temp1.next;
+                } else {
+                    temp.next = temp2;
+                    temp2 = temp2.next;
+                }
+                temp = temp.next;
+            }
+            if (temp1 == null) {
+                temp.next = temp2;
+            } else {
+                temp.next = temp1;
+            }
+            return dummy.next;
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/leetcode/editor/cn/P46Permutations.java

@@ -0,0 +1,98 @@
+  //给定一个不含重复数字的数组 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 中的所有整数 互不相同 
+// 
+//
+// Related Topics 数组 回溯 👍 3004 👎 0
+
+
+  package leetcode.editor.cn;
+
+  import java.util.ArrayDeque;
+  import java.util.ArrayList;
+  import java.util.Arrays;
+  import java.util.Deque;
+  import java.util.List;
+  public class P46Permutations{
+      public static void main(String[] args) {
+              int[] nums = {1, 2, 3};
+              Solution solution = new P46Permutations().new Solution();
+              List<List<Integer>> lists = solution.permute(nums);
+              System.out.println(lists);
+      }
+      //leetcode submit region begin(Prohibit modification and deletion)
+
+
+
+
+
+
+      public class Solution {
+
+          public List<List<Integer>> permute(int[] nums) {
+              int len = nums.length;
+              // 使用一个动态数组保存所有可能的全排列
+              List<List<Integer>> res = new ArrayList<>();
+              if (len == 0) {
+                  return res;
+              }
+              boolean[] used = new boolean[len];
+              List<Integer> list = Arrays.asList(new Integer[nums.length]);
+              dfs(used, len, res, nums, list, 0);
+              return res;
+          }
+
+          private void dfs(boolean[] used, int len, List<List<Integer>> res, int[] nums, List<Integer> path, int deph) {
+              if (deph == len) {
+                  res.add(new ArrayList<>(path));
+                  return;
+              }
+
+              for (int i = 0; i < len; i++) {
+                  if (!used[i]) {
+                      used[i] = true;
+                      path.set(deph, nums[i]);
+                      dfs(used, len, res, nums, path, deph + 1);
+                      used[i] = false;
+                  }
+              }
+
+          }
+
+
+      }
+
+
+//leetcode submit region end(Prohibit modification and deletion)
+
+  }