Added tasks 144-146.

Author: javadev

src/main/java/g0101_0200/s0144_binary_tree_preorder_traversal/Solution.java

@@ -0,0 +1,42 @@
+package g0101_0200.s0144_binary_tree_preorder_traversal;
+
+import com_github_leetcode.TreeNode;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+/*
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+@SuppressWarnings("java:S1149")
+public class Solution {
+    public List<Integer> preorderTraversal(TreeNode root) {
+        List<Integer> result = new ArrayList<>();
+        if (root == null) {
+            return result;
+        }
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode current = root;
+        while (current != null || !stack.isEmpty()) {
+            while (current != null) {
+                result.add(current.val);
+                stack.push(current.right);
+                current = current.left;
+            }
+            current = stack.pop();
+        }
+        return result;
+    }
+}

src/main/java/g0101_0200/s0145_binary_tree_postorder_traversal/Solution.java

@@ -0,0 +1,32 @@
+package g0101_0200.s0145_binary_tree_postorder_traversal;
+
+import com_github_leetcode.TreeNode;
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<Integer> postorderTraversal(TreeNode root) {
+        if (root == null) {
+            return new ArrayList<>();
+        }
+        List<Integer> res = postorderTraversal(root.left);
+        res.addAll(postorderTraversal(root.right));
+        res.add(root.val);
+        return res;
+    }
+}

src/main/java/g0101_0200/s0146_lru_cache/LRUCache.java

@@ -0,0 +1,119 @@
+package g0101_0200.s0146_lru_cache;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LRUCache {
+    int capacity;
+    Map<Integer, LRUCacheNode> cacheMap = new HashMap<>();
+    // insert here
+    LRUCacheNode head;
+    // remove here
+    LRUCacheNode tail;
+
+    public LRUCache(int cap) {
+        capacity = cap;
+    }
+
+    public int get(int key) {
+        LRUCacheNode val = cacheMap.get(key);
+        if (val == null) {
+            return -1;
+        }
+        moveToHead(val);
+        return val.value;
+    }
+
+    /*
+     * Scenarios :
+     * 1. Value key is already present.
+     * 		update
+     * 		move node to head
+     * 2. cache is not full
+     * 		cache is empty (create node and assign head and tail)
+     * 		cache is partially empty (add node to head and update head pointer)
+     * 3. cache is full
+     * 		remove node at tail, update head, tail pointers
+     * 		Recursively call put
+     *
+     *
+     * move node to head Scenarios
+     * 1. node is at head
+     * 2. node is at tail
+     * 3. node is in middle
+     *
+     */
+    public void put(int key, int value) {
+        LRUCacheNode valNode = cacheMap.get(key);
+        if (valNode != null) {
+            valNode.value = value;
+            moveToHead(valNode);
+        } else {
+            if (cacheMap.size() < capacity) {
+                if (cacheMap.size() == 0) {
+                    LRUCacheNode node = new LRUCacheNode(key, value);
+                    cacheMap.put(key, node);
+                    head = node;
+                    tail = node;
+                } else {
+                    LRUCacheNode node = new LRUCacheNode(key, value);
+                    cacheMap.put(key, node);
+                    node.next = head;
+                    head.prev = node;
+                    head = node;
+                }
+            } else {
+                // remove from tail
+                LRUCacheNode last = tail;
+                tail = last.prev;
+                if (tail != null) {
+                    tail.next = null;
+                }
+                cacheMap.remove(last.key);
+                if (cacheMap.size() == 0) {
+                    head = null;
+                }
+                // Call recursively
+                put(key, value);
+            }
+        }
+    }
+
+    /*
+     * check for 3 conditions
+     * 1. node is already at head
+     * 2. Node is tail node
+     * 3. Node in middle node
+     */
+    private void moveToHead(LRUCacheNode node) {
+        if (node == head) {
+            return;
+        }
+        if (node == tail) {
+            tail = node.prev;
+        }
+        // node is not head, it should have some valid prev node
+        LRUCacheNode prev = node.prev;
+        LRUCacheNode next = node.next;
+        prev.next = next;
+        if (next != null) {
+            next.prev = prev;
+        }
+        node.prev = null;
+        node.next = head;
+        head.prev = node;
+        head = node;
+    }
+}
+
+class LRUCacheNode {
+    int key;
+    int value;
+    LRUCacheNode prev;
+    LRUCacheNode next;
+
+    public LRUCacheNode(int k, int v) {
+        key = k;
+        value = v;
+    }
+}

src/test/java/g0101_0200/s0144_binary_tree_preorder_traversal/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0101_0200.s0144_binary_tree_preorder_traversal;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.TreeNode;
+import java.util.Arrays;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void preorderTraversal() {
+        TreeNode treeNode = new TreeNode(1);
+        treeNode.right = new TreeNode(2);
+        treeNode.right.left = new TreeNode(3);
+        assertThat(new Solution().preorderTraversal(treeNode), equalTo(Arrays.asList(1, 2, 3)));
+    }
+}

src/test/java/g0101_0200/s0145_binary_tree_postorder_traversal/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0101_0200.s0145_binary_tree_postorder_traversal;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.TreeNode;
+import java.util.Arrays;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void postorderTraversal() {
+        TreeNode treeNode = new TreeNode(1);
+        treeNode.right = new TreeNode(2);
+        treeNode.right.left = new TreeNode(3);
+        assertThat(new Solution().postorderTraversal(treeNode), equalTo(Arrays.asList(3, 2, 1)));
+    }
+}

src/test/java/g0101_0200/s0146_lru_cache/LRUCacheTest.java

@@ -0,0 +1,31 @@
+package g0101_0200.s0146_lru_cache;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class LRUCacheTest {
+    @Test
+    public void lRUCache() {
+        LRUCache lRUCache = new LRUCache(2);
+        // cache is {1=1}
+        lRUCache.put(1, 1);
+        // cache is {1=1, 2=2}
+        lRUCache.put(2, 2);
+        // return 1
+        assertThat(lRUCache.get(1), equalTo(1));
+        // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
+        lRUCache.put(3, 3);
+        // returns -1 (not found)
+        assertThat(lRUCache.get(2), equalTo(-1));
+        // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
+        lRUCache.put(4, 4);
+        // return -1 (not found)
+        assertThat(lRUCache.get(1), equalTo(-1));
+        // return 3
+        assertThat(lRUCache.get(3), equalTo(3));
+        // return 4
+        assertThat(lRUCache.get(4), equalTo(4));
+    }
+}