code is added by anjha1

Author: anjha1

0141.linked-list-cycle/LinkedListCycle.java

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class LinkedListCycle {
+    public boolean hasCycle(ListNode head) {
+        if (head == null) return false;
+
+        ListNode l1 = head, l2 = head.next;
+        while (l1 != null && l2 != null && l2.next != null) {
+            if (l1 == l2) {
+                return true;
+            }
+            l1 = l1.next;
+            l2 = l2.next.next;
+        }
+
+        return false;
+    }
+}

0141.linked-list-cycle/README.md

@@ -0,0 +1 @@
+# [141. Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/)

0142.linked-list-cycle-ii/LinkedListCycleIi.java

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class LinkedListCycleIi {
+    public ListNode detectCycle(ListNode head) {
+        ListNode slow = head, fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+            if (slow == fast) break;
+        }
+        if (fast == null || fast.next == null) return null;
+        while (head != slow) {
+            head = head.next;
+            slow = slow.next;
+        }
+        return head;
+    }
+}

0142.linked-list-cycle-ii/README.md

@@ -0,0 +1,2 @@
+# [142. Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/)
+

0144.binary-tree-preorder-traversal/BinaryTreePreorderTraversal.java

@@ -0,0 +1,34 @@
+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;
+ *     }
+ * }
+ */
+class BinaryTreePreorderTraversal {
+    public List<Integer> preorderTraversal(TreeNode root) {
+        List<Integer> ret = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode node = stack.pop();
+            if (node == null) continue;
+            ret.add(node.val);
+            stack.push(node.right);
+            stack.push(node.left);
+        }
+        return ret;
+    }
+}

0144.binary-tree-preorder-traversal/README.md

@@ -0,0 +1 @@
+# [144. Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/)

0145.binary-tree-postorder-traversal/BinaryTreePostorderTraversal.java

@@ -0,0 +1,36 @@
+import java.util.ArrayList;
+import java.util.Collections;
+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;
+ *     }
+ * }
+ */
+class BinaryTreePostorderTraversal {
+    public List<Integer> postorderTraversal(TreeNode root) {
+        List<Integer> ret = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode node = stack.pop();
+            if (node == null) continue;
+            ret.add(node.val);
+            stack.push(node.left);
+            stack.push(node.right);
+        }
+        Collections.reverse(ret);
+        return ret;
+    }
+}

0145.binary-tree-postorder-traversal/README.md

@@ -0,0 +1,2 @@
+# [145. Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/)
+

0148.sort-list/README.md

@@ -0,0 +1 @@
+# [148. Sort List](https://leetcode.com/problems/sort-list/)

0148.sort-list/SortList.java

@@ -0,0 +1,48 @@
+/**
+ * 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 SortList {
+    private ListNode getMid(ListNode head) {
+        ListNode midPrev = null;
+        while (head != null && head.next != null) {
+            midPrev = (midPrev == null) ? head : midPrev.next;
+            head = head.next.next;
+        }
+        ListNode mid = midPrev.next;
+        midPrev.next = null;
+        return mid;
+    }
+
+    private ListNode merge(ListNode list1, ListNode list2) {
+        ListNode dummyHead = new ListNode(0);
+        ListNode tail = dummyHead;
+        while (list1 != null && list2 != null) {
+            if (list1.val < list2.val) {
+                tail.next = list1;
+                list1 = list1.next;
+                tail = tail.next;
+            } else {
+                tail.next = list2;
+                list2 = list2.next;
+                tail = tail.next;
+            }
+        }
+        tail.next = (list1 != null) ? list1 : list2;
+        return dummyHead.next;
+    }
+
+    public ListNode sortList(ListNode head) {
+        if (head == null || head.next == null) return head;
+        ListNode mid = getMid(head);
+        ListNode left = sortList(head);
+        ListNode right = sortList(mid);
+        return merge(left, right);
+    }
+}

0150.evaluate-reverse-polish-notation/EvaluateReversePolishNotation.java

@@ -0,0 +1,35 @@
+import java.util.Stack;
+
+class EvaluateReversePolishNotation {
+    public int evalRPN(String[] tokens) {
+        Stack<Integer> stack = new Stack<>();
+        for (String token : tokens) {
+            if (isNumber(token)) {
+                stack.push(Integer.parseInt(token));
+            } else {
+                int num2 = stack.pop();
+                int num1 = stack.pop();
+                switch (token) {
+                    case "+":
+                        stack.push(num1 + num2);
+                        break;
+                    case "-":
+                        stack.push(num1 - num2);
+                        break;
+                    case "*":
+                        stack.push(num1 * num2);
+                        break;
+                    case "/":
+                        stack.push(num1 / num2);
+                        break;
+                    default:
+                }
+            }
+        }
+        return stack.pop();
+    }
+
+    private boolean isNumber(String token) {
+        return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
+    }
+}

0150.evaluate-reverse-polish-notation/README.md

@@ -0,0 +1 @@
+# [150. Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/)

0151.reverse-words-in-a-string/README.md

@@ -0,0 +1,2 @@
+# [151. Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/)
+

0151.reverse-words-in-a-string/ReverseWordsInAString.java

@@ -0,0 +1,42 @@
+class ReverseWordsInAString {
+    private void reverse(char[] a, int i, int j) {
+        while (i < j) {
+            char t = a[i];
+            a[i++] = a[j];
+            a[j--] = t;
+        }
+    }
+
+    private void reverseWords(char[] a, int n) {
+        int i = 0, j = 0;
+
+        while (i < n) {
+            while (i < j || i < n && a[i] == ' ') i++;
+            while (j < i || j < n && a[j] != ' ') j++;
+            reverse(a, i, j - 1);
+        }
+    }
+
+    private String cleanSpaces(char[] a, int n) {
+        int i = 0, j = 0;
+        while (j < n) {
+            while (j < n && a[j] == ' ') j++;
+            while (j < n && a[j] != ' ') a[i++] = a[j++];
+            while (j < n && a[j] == ' ') j++;
+            if (j < n) a[i++] = ' ';
+        }
+
+        return new String(a).substring(0, i);
+    }
+
+    public String reverseWords(String s) {
+        if (s == null) return null;
+
+        char[] a = s.toCharArray();
+        int n = a.length;
+
+        reverse(a, 0, n - 1);
+        reverseWords(a, n);
+        return cleanSpaces(a, n);
+    }
+}

0152.maximum-product-subarray/MaximumProductSubarray.java

@@ -0,0 +1,14 @@
+class MaximumProductSubarray {
+    public int maxProduct(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+
+        int max = nums[0], min = nums[0], result = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            int temp = max;
+            max = Math.max(Math.max(max * nums[i], min * nums[i]), nums[i]);
+            min = Math.min(Math.min(temp * nums[i], min * nums[i]), nums[i]);
+            if (max > result) result = max;
+        }
+        return result;
+    }
+}

0152.maximum-product-subarray/README.md

@@ -0,0 +1 @@
+# [152. Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray/)

0153.find-minimum-in-rotated-sorted-array/FindMinimumInRotatedSortedArray.java

@@ -0,0 +1,14 @@
+class FindMinimumInRotatedSortedArray {
+    public int findMin(int[] nums) {
+        int l = 0, h = nums.length - 1;
+        while (l < h) {
+            int m = l + (h - l) / 2;
+            if (nums[m] <= nums[h]) {
+                h = m;
+            } else {
+                l = m + 1;
+            }
+        }
+        return nums[l];
+    }
+}

0153.find-minimum-in-rotated-sorted-array/README.md

@@ -0,0 +1 @@
+# [153. Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/)

0155.min-stack/MinStack.java

@@ -0,0 +1,42 @@
+import java.util.Stack;
+
+class MinStack {
+    private Stack<Integer> dataStack;
+    private Stack<Integer> minStack;
+    private int min;
+
+    public MinStack() {
+        dataStack = new Stack<>();
+        minStack = new Stack<>();
+        min = Integer.MAX_VALUE;
+    }
+    
+    public void push(int val) {
+        dataStack.push(val);
+        min = Math.min(min, val);
+        minStack.push(min);
+    }
+    
+    public void pop() {
+        dataStack.pop();
+        minStack.pop();
+        min = minStack.isEmpty() ? Integer.MAX_VALUE : minStack.peek();
+    }
+    
+    public int top() {
+        return dataStack.peek();
+    }
+    
+    public int getMin() {
+        return minStack.peek();
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack obj = new MinStack();
+ * obj.push(val);
+ * obj.pop();
+ * int param_3 = obj.top();
+ * int param_4 = obj.getMin();
+ */

0155.min-stack/README.md

@@ -0,0 +1 @@
+# [155. Min Stack](https://leetcode.com/problems/min-stack/)

0160.intersection-of-two-linked-lists/IntersectionOfTwoLinkedLists.java

@@ -0,0 +1,21 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class IntersectionOfTwoLinkedLists {
+    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+        ListNode l1 = headA, l2 = headB;
+        while (l1 != l2) {
+            l1 = (l1 == null) ? headB : l1.next;
+            l2 = (l2 == null) ? headA : l2.next;
+        }
+        return l1;
+    }
+}

0160.intersection-of-two-linked-lists/README.md

@@ -0,0 +1,2 @@
+# [160. Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/)
+