Solution is Added by anjha

Author: anjha1

0231.power-of-two/PowerOfTwo.java

@@ -0,0 +1,5 @@
+class PowerOfTwo {
+    public boolean isPowerOfTwo(int n) {
+        return n > 0 && (n & (n - 1)) == 0;
+    }
+}

0231.power-of-two/README.md

@@ -0,0 +1 @@
+# [231. Power of Two](https://leetcode.com/problems/power-of-two/)

0232.implement-queue-using-stacks/ImplementQueueUsingStacks.java

@@ -0,0 +1,46 @@
+import java.util.Stack;
+
+class MyQueue {
+    Stack<Integer> inStack;
+    Stack<Integer> outStack;
+
+    public MyQueue() {
+        inStack = new Stack<>();
+        outStack = new Stack<>();
+    }
+    
+    public void push(int x) {
+        inStack.push(x);
+    }
+    
+    public int pop() {
+        in2out();
+        return outStack.pop();
+    }
+
+    public int peek() {
+        in2out();
+        return outStack.peek();
+    }
+
+    public boolean empty() {
+        return inStack.isEmpty() && outStack.isEmpty();
+    }
+
+    private void in2out() {
+        if (outStack.isEmpty()) {
+            while (!inStack.isEmpty()) {
+                outStack.push(inStack.pop());
+            }
+        }
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * MyQueue obj = new MyQueue();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.peek();
+ * boolean param_4 = obj.empty();
+ */

0232.implement-queue-using-stacks/README.md

@@ -0,0 +1,8 @@
+# [232. Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(1)$. push and empty are $O(1)$ and pop and peek are $O(1)$ in average. For each element, it will push and pop to the stacks twice, so the average time complexity is $O(1)$.
+- Space Complexity: $O(n)$. $n$ is the size of the elements. We have $n$ elements in queue, so the space complexity is $O(n)$.

0234.palindrome-linked-list/PalindromeLinkedList.java

@@ -0,0 +1,50 @@
+/**
+ * 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 PalindromeLinkedList {
+    private void cut(ListNode head, ListNode cutNode) {
+        while (head.next != cutNode) {
+            head = head.next;
+        }
+        head.next = null;
+    }
+
+    private ListNode reverse(ListNode head) {
+        ListNode newHead = null;
+        while (head != null) {
+            ListNode nextNode = head.next;
+            head.next = newHead;
+            newHead = head;
+            head = nextNode;
+        }
+        return newHead;
+    }
+
+    private boolean isEqual(ListNode l1, ListNode l2) {
+        while (l1 != null && l2 != null) {
+            if (l1.val != l2.val) return false;
+            l1 = l1.next;
+            l2 = l2.next;
+        }
+        return true;
+    }
+
+    public boolean isPalindrome(ListNode head) {
+        if (head == null || head.next == null) return true;
+        ListNode slow = head, fast = head.next;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        if (fast != null) slow = slow.next;
+        cut(head, slow);
+        return isEqual(head, reverse(slow));
+    }
+}

0234.palindrome-linked-list/README.md

@@ -0,0 +1,2 @@
+# [234. Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/)
+

0235.lowest-common-ancestor-of-a-binary-search-tree/LowestCommonAncestorOfABinarySearchTree.java

@@ -0,0 +1,17 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+
+class LowestCommonAncestorOfABinarySearchTree {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
+        if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+        return root;
+    }
+}

0235.lowest-common-ancestor-of-a-binary-search-tree/README.md

@@ -0,0 +1 @@
+# [235. Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)

0236.lowest-common-ancestor-of-a-binary-tree/LowestCommonAncestorOfABinaryTree.java

@@ -0,0 +1,17 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class LowestCommonAncestorOfABinaryTree {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null || root == p || root == q) return root;
+        TreeNode left = lowestCommonAncestor(root.left, p , q);
+        TreeNode right = lowestCommonAncestor(root.right, p, q);
+        return left == null ? right : right == null ? left : root;
+    }
+}

0236.lowest-common-ancestor-of-a-binary-tree/README.md

@@ -0,0 +1 @@
+# [236. Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/)

0237.delete-node-in-a-linked-list/DeleteNodeInALinkedList.java

@@ -0,0 +1,16 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class DeleteNodeInALinkedList {
+    public void deleteNode(ListNode node) {
+        ListNode nextNode = node.next;
+        node.val = nextNode.val;
+        node.next = nextNode.next;
+        nextNode.next = null;
+    }
+}

0237.delete-node-in-a-linked-list/README.md

@@ -0,0 +1 @@
+# [237. Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/)

0238.product-of-array-except-self/ProductOfArrayExceptSelf.java

@@ -0,0 +1,21 @@
+class ProductOfArrayExceptSelf {
+    public int[] productExceptSelf(int[] nums) {
+        int n = nums.length;
+        int[] left = new int[n];
+        int[] right = new int[n];
+
+        left[0] = 1;
+        for (int i = 1; i < n; i++)
+            left[i] = left[i - 1] * nums[i - 1];
+
+        right[n - 1] = 1;
+        for (int i = n - 2; i >= 0; i--)
+            right[i] = right[i + 1] * nums[i + 1];
+
+        int[] ans = new int[n];
+        for (int i = 0; i < n; i++)
+            ans[i] = left[i] * right[i];
+
+        return ans;
+    }
+}

0238.product-of-array-except-self/README.md

@@ -0,0 +1,2 @@
+# [238. Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/)
+

0240.search-a-2d-matrix-ii/README.md

@@ -0,0 +1 @@
+# [240. Search a 2D Matrix II](https://leetcode.com/problems/search-a-2d-matrix-ii/)

0240.search-a-2d-matrix-ii/SearchA2dMatrixIi.java

@@ -0,0 +1,13 @@
+class SearchA2dMatrixIi {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
+        int m = matrix.length, n = matrix[0].length;
+        int row = 0, col = n - 1;
+        while (row < m && col >= 0) {
+            if (matrix[row][col] == target) return true;
+            else if (target < matrix[row][col]) col--;
+            else row++;
+        }
+        return false;
+    }
+}

0241.different-ways-to-add-parentheses/DifferentWaysToAddParentheses.java

@@ -0,0 +1,34 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class DifferentWaysToAddParentheses {
+    public List<Integer> diffWaysToCompute(String expression) {
+        List<Integer> ways = new ArrayList<>();
+        for (int i = 0; i < expression.length(); i++) {
+            char c = expression.charAt(i);
+            if (c == '+' || c == '-' || c == '*') {
+                List<Integer> left = diffWaysToCompute(expression.substring(0, i));
+                List<Integer> right = diffWaysToCompute(expression.substring(i+1));
+                for (int l : left) {
+                    for (int r : right) {
+                        switch (c) {
+                            case '+':
+                                ways.add(l + r);
+                                break;
+                            case '-':
+                                ways.add(l - r);
+                                break;
+                            case '*':
+                                ways.add(l * r);
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        if (ways.size() == 0) {
+            ways.add(Integer.valueOf(expression));
+        }
+        return ways;
+    }
+}

0241.different-ways-to-add-parentheses/README.md

@@ -0,0 +1 @@
+# [241. Different Ways to Add Parentheses](https://leetcode.com/problems/different-ways-to-add-parentheses/)

0242.valid-anagram/README.md

@@ -0,0 +1 @@
+# [242. Valid Anagram](https://leetcode.com/problems/valid-anagram/)

0242.valid-anagram/ValidAnagram.java

@@ -0,0 +1,15 @@
+class ValidAnagram {
+    public boolean isAnagram(String s, String t) {
+        int[] counts = new int[26];
+        for (char c : s.toCharArray()) {
+            counts[c - 'a']++;
+        }
+        for (char c : t.toCharArray()) {
+            counts[c - 'a']--;
+        }
+        for (int count: counts) {
+            if (count != 0) return false;
+        }
+        return true;
+    }
+}

0258.add-digits/AddDigits.java

@@ -0,0 +1,13 @@
+class AddDigits {
+    public int addDigits(int num) {
+        while (num >= 10) {
+            int sum = 0;
+            while (num > 0) {
+                sum += num % 10;
+                num /= 10;
+            }
+            num = sum;
+        }
+        return num;
+    }
+}

0258.add-digits/README.md

@@ -0,0 +1,8 @@
+# [258. Add Digits](https://leetcode.com/problems/add-digits/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(\log n)$.
+- Space Complexity: $O(1)$.

0260.single-number-iii/README.md

@@ -0,0 +1 @@
+# [260. Single Number III](https://leetcode.com/problems/single-number-iii/)

0260.single-number-iii/SingleNumberIii.java

@@ -0,0 +1,13 @@
+class SingleNumberIii {
+    public int[] singleNumber(int[] nums) {
+        int diff = 0;
+        for (int num : nums) diff ^= num;
+        diff &= -diff;
+        int[] ret = new int[2];
+        for (int num : nums) {
+            if ((num & diff) == 0) ret[0] ^= num;
+            else ret[1] ^= num;
+        }
+        return ret;
+    }
+}