fd

Author: dingjikerbo

leetcode/solution/src/InorderSuccessorInBST.java

@@ -29,32 +29,8 @@ public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
         return null;
     }
 
+    // 耗时2ms，简单的递归写法，更容易理解
     /**
-     * p的下一个节点一定是比p大的，所以如果p没有右子树，则结果是p的父节点，如果有右子树则是右子树中最小的节点。
-     * 所以这里遍历时当p的值小于当前节点，则当前节点可作为备选，同时往左走。如果在遍历过程中遇到仍然比p大的，说明更接近p，则更新备选。
-     * 如果遇到比p小的，就往右走
-     * <p>
-     * 有两点要注意，
-     * 1， 首先res初始要为null，一个节点时，或root为null时，或p为最大节点时，res都没机会赋值
-     * 2， 当root迭代到等于p时，走哪个分支呢，为什么选root = root.right，假如root.right为空，则之前的res即可，否则
-     * 下一个迭代肯定走到root.val > p.val分支中，更新res。
-     */
-    // 耗时4ms
-    public TreeNode inorderSuccessor2(TreeNode root, TreeNode p) {
-        TreeNode res = null;
-        while (root != null) {
-            if (root.val > p.val) {
-                res = root;
-                root = root.left;
-            } else {
-                root = root.right;
-            }
-        }
-        return res;
-    }
-
-    // 耗时2ms，简单的递归写法
-    /*
     public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
         if (root == null) {
             return null;
@@ -79,6 +55,21 @@ public TreeNode predecessor(TreeNode root, TreeNode p) {
         }
     }*/
 
+    // 给上面的递归换成迭代写法
+    // 耗时4ms
+    public TreeNode inorderSuccessor2(TreeNode root, TreeNode p) {
+        TreeNode res = null;
+        while (root != null) {
+            if (root.val > p.val) {
+                res = root;
+                root = root.left;
+            } else {
+                root = root.right;
+            }
+        }
+        return res;
+    }
+
     /**
      * http://www.geeksforgeeks.org/?p=9999
      * 给定Node，求其successor，步骤如下：

leetcode/solution/src/LRUCache.java

@@ -0,0 +1,64 @@
+import java.util.HashMap;
+
+public class LRUCache {
+
+    private Node mHead;
+    private HashMap<Integer, Node> mMap;
+    private int mCapacity;
+
+    public LRUCache(int capacity) {
+        mMap = new HashMap<>();
+        mCapacity = capacity;
+        mHead = new Node(0, 0);
+    }
+
+    public int get(int key) {
+        if (!mMap.containsKey(key)) {
+            return -1;
+        }
+        Node node = mMap.get(key);
+        node.remove();
+        node.add(mHead);
+        return node.val;
+    }
+
+    public void put(int key, int value) {
+        Node node = mMap.get(key);
+        if (node == null) {
+            node = new Node(key, value);
+            mMap.put(key, node);
+        } else {
+            node.val = value;
+            node.remove();
+        }
+        node.add(mHead);
+        if (mMap.size() > mCapacity) {
+            Node prev = mHead.prev;
+            prev.remove();
+            mMap.remove(prev.key);
+        }
+    }
+
+    class Node {
+        Node prev, next;
+        int key, val;
+
+        Node(int key, int val) {
+            this.key = key;
+            this.val = val;
+            prev = next = this;
+        }
+
+        void remove() {
+            prev.next = next;
+            next.prev = prev;
+        }
+
+        void add(Node head) {
+            next = head.next;
+            head.next.prev = this;
+            prev = head;
+            head.next = this;
+        }
+    }
+}

leetcode/solution/src/TwoSum.java

@@ -1,40 +1,16 @@
 import java.util.HashMap;
 
-/**
- * https://leetcode.com/articles/two-sum/
- */
 public class TwoSum {
 
     /**
-     * 如果符合条件的不止一组呢？则找到一组就从map删除一组
-     * 要注意排除index != i
-     */
-    public int[] twoSum(int[] nums, int target) {
-        HashMap<Integer, Integer> map = new HashMap<>();
-        for (int i = 0; i < nums.length; i++) {
-            map.put(nums[i], i);
-        }
-        for (int i = 0; i < nums.length; i++) {
-            Integer index = map.get(target - nums[i]);
-            if (index != null && index != i) {
-                return new int[] {
-                        i, index
-                };
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 只循环一轮
+     * one pass
      * 要注意map.put要放在for末尾，对于case[3, 3], target=6的情况，如果放在开头会覆盖第一个3
      */
     public int[] twoSum2(int[] nums, int target) {
         HashMap<Integer, Integer> map = new HashMap<>();
         for (int i = 0; i < nums.length; i++) {
-            int k = map.getOrDefault(target - nums[i], -1);
-            if (k >= 0 && k != i) {
-                return new int[] {i, k};
+            if (map.containsKey(target - nums[i])) {
+                return new int[] {map.get(target - nums[i]), i};
             }
             map.put(nums[i], i);
         }

leetcode/src/Main.java

@@ -2,37 +2,70 @@
 
 public class Main {
 
-    class TwoSum {
+    class LRUCache {
 
-        HashMap<Integer, Integer> map;
+        class Node {
+            Node prev, next;
+            int key, val;
 
-        /** Initialize your data structure here. */
-        public TwoSum() {
-            map = new HashMap<>();
+            Node(int key, int val) {
+                this.key = key;
+                this.val = val;
+                prev = next = this;
+            }
+
+            void remove() {
+                prev.next = next;
+                next.prev = prev;
+            }
+
+            void add(Node head) {
+                next = head.next;
+                head.next.prev = this;
+                prev = head;
+                head.next = this;
+            }
         }
 
-        /** Add the number to an internal data structure.. */
-        public void add(int number) {
-            map.put(number, map.getOrDefault(number, 0) + 1);
+        private Node mHead;
+        private HashMap<Integer, Node> mMap;
+        private int mCapacity;
+
+        public LRUCache(int capacity) {
+            mMap = new HashMap<>();
+            mCapacity = capacity;
+            mHead = new Node(0, 0);
         }
 
-        /** Find if there exists any pair of numbers which sum is equal to the value. */
-        public boolean find(int value) {
-            for (int k : map.keySet()) {
-                int n = map.getOrDefault(value - k, -1);
-                if (value - k != k && n > 0) {
-                    return true;
-                }
-                if (value - k == k && n > 1) {
-                    return true;
-                }
+        public int get(int key) {
+            if (!mMap.containsKey(key)) {
+                return -1;
+            }
+            Node node = mMap.get(key);
+            node.remove();
+            node.add(mHead);
+            return node.val;
+        }
+
+        public void put(int key, int value) {
+            Node node = mMap.get(key);
+            if (node == null) {
+                node = new Node(key, value);
+                mMap.put(key, node);
+            } else {
+                node.val = value;
+                node.remove();
+            }
+            node.add(mHead);
+            if (mMap.size() > mCapacity) {
+                Node prev = mHead.prev;
+                prev.remove();
+                mMap.remove(prev.key);
             }
-            return false;
         }
     }
 
     public static void main(String[] args) {
-        int[] res = twoSum(new int[]{3,2,3}, 6);
-        System.out.println(String.format("%d - %d", res[0], res[1]));
+
     }
 }