Added Binary Search Problems in Java

Author: devangi2000

Backtracking/Sudoku-Solver-37.java

@@ -34,3 +34,39 @@
 // board[i][j] is a digit or '.'.
 // It is guaranteed that the input board has only one solution.
 
+class Solution {
+    public boolean isValid(char[][] board, int row, int col, char c){
+        for(int i = 0; i < 9; i++){
+            if(board[row][i] == c)
+                return false;
+            if(board[i][col] == c)
+                return false;
+            if(board[3*(row/3) + (i/3)][3*(col/3) + (i%3)] == c)
+                return false;
+        }
+        return true;
+    }
+    
+    public boolean solve(char[][] board){
+        for(int i = 0; i < board.length; i++){
+            for(int j = 0; j < board[0].length; j++){
+                if(board[i][j] == '.'){
+                    for(char c = '1'; c <= '9'; c++){
+                        if(isValid(board, i, j, c)){
+                            board[i][j] = c;
+                            if(solve(board)) return true;
+                            else board[i][j] = '.';
+                        }
+                    }
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    
+    public void solveSudoku(char[][] board) {
+        solve(board);
+    }
+}
+

Binary-Search/Search-in-Rotated-Sorted-Array-33.java

@@ -0,0 +1,53 @@
+// There is an integer array nums sorted in ascending order (with distinct values).
+// Prior to being passed to your function, nums is rotated at an unknown pivot index 
+// k (0 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1],
+//                                                            ..., nums[n-1], 
+//                                                            nums[0], nums[1], ..., nums[k-1]] (0-indexed). 
+//   For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].
+
+// Given the array nums after the rotation and an integer target, return the index of target
+// if it is in nums, or -1 if it is not in nums.
+// You must write an algorithm with O(log n) runtime complexity.
+
+// Example 1:
+
+// Input: nums = [4,5,6,7,0,1,2], target = 0
+// Output: 4
+// Example 2:
+
+// Input: nums = [4,5,6,7,0,1,2], target = 3
+// Output: -1
+// Example 3:
+
+// Input: nums = [1], target = 0
+// Output: -1 
+
+// Constraints:
+
+// 1 <= nums.length <= 5000
+// -104 <= nums[i] <= 104
+// All values of nums are unique.
+// nums is guaranteed to be rotated at some pivot.
+// -104 <= target <= 104
+
+class Solution {
+    public int search(int[] nums, int target) {
+        int start = 0, end = nums.length - 1, mid = 0;
+        while(start <= end){
+            mid = start + (end - start) / 2;
+            if(nums[mid] == target)
+                return mid;
+            else if(nums[mid] >= nums[start]){
+                if(nums[start] <= target && nums[mid] >= target)
+                    end = mid - 1;
+                else start = mid + 1;
+            }
+            else if(nums[mid] <= nums[end]){
+                if(target >= nums[mid] && target <= nums[end])
+                    start = mid + 1;
+                else end = mid - 1;
+            }
+        }
+        return -1;
+    }
+}

Binary-Search/SingleElementInASortedArray.cpp renamed to Binary-Search/SingleElementInASortedArray540.cpp

@@ -0,0 +1,37 @@
+// You are given a sorted array consisting of only integers where every element 
+// appears exactly twice, except for one element which appears exactly once. 
+// Find this single element that appears only once.
+
+// Follow up: Your solution should run in O(log n) time and O(1) space. 
+
+// Example 1:
+
+// Input: nums = [1,1,2,3,3,4,4,8,8]
+// Output: 2
+// Example 2:
+
+// Input: nums = [3,3,7,7,10,11,11]
+// Output: 10
+ 
+// Constraints:
+// 1 <= nums.length <= 10^5
+// 0 <= nums[i] <= 10^5
+class Solution {
+    public int singleNonDuplicate(int[] nums) {
+        int start = 0, end = nums.length - 1;
+        if(end == 0) return nums[0];
+        if(nums[0] != nums[1]) return nums[0];
+        if(nums[end - 1] != nums[end]) return nums[end];
+        while(start <= end){
+            int mid = start + (end - start) / 2;
+            if(nums[mid] != nums[mid + 1] && nums[mid] != nums[mid-1])
+                return nums[mid];
+            if(((mid % 2 == 0) && nums[mid] == nums[mid + 1]) ||
+               ((mid % 2 == 1) && nums[mid] == nums[mid - 1]))
+                start = mid + 1;
+            else
+                end = mid - 1;
+        }
+        return -1;
+    }
+}

Binary-Search/SingleElementInASortedArray540.java

@@ -0,0 +1,45 @@
+// Given the root of a binary tree, invert the tree, and return its root.
+
+// Example 1:
+
+// Input: root = [4,2,7,1,3,6,9]
+// Output: [4,7,2,9,6,3,1]
+// Example 2:
+
+
+// Input: root = [2,1,3]
+// Output: [2,3,1]
+// Example 3:
+
+// Input: root = []
+// Output: [] 
+
+// Constraints:
+
+// The number of nodes in the tree is in the range [0, 100].
+// -100 <= Node.val <= 100
+/**
+ * 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 Solution {
+    public TreeNode invertTree(TreeNode root) {
+        if(root == null)
+            return root;
+        TreeNode temp = root.left;
+        root.left = invertTree(root.right);
+        root.right = invertTree(temp);
+        return root;
+    }
+}