Update

Author: fibers

src/main/java/com/fibers/algorithm/leetcode/_033/Solution.java

@@ -8,15 +8,23 @@ public int search(int[] nums, int target) {
         int start = 0;
         int end = nums.length - 1;
         while (start <= end) {
-            if (start == end) {
-                return target == nums[start] ? start : -1;
-            }
             int mid = (start + end) / 2;
-            if ((nums[mid] < nums[end] && (nums[mid] < target && target <= nums[end])) ||
-                    ((nums[mid] < target || target <= nums[end]) && nums[mid] > nums[end])) {
-                start = mid + 1;
+            if (nums[mid] == target) {
+                return start;
+            }
+
+            if (nums[mid] <= nums[end]) {
+                if (nums[mid] < target && target <= nums[end]) {
+                    start = mid + 1;
+                } else {
+                    end = mid - 1;
+                }
             } else {
-                end = mid;
+                if (nums[mid] < target || target <= nums[end]) {
+                    start = mid + 1;
+                } else {
+                    end = mid - 1;
+                }
             }
         }
         return -1;

src/main/java/com/fibers/algorithm/leetcode/_069/Solution.java

@@ -1,4 +1,26 @@
 package com.fibers.algorithm.leetcode._069;
+
 public class Solution {
+
+    public int mySqrt(int x) {
+        if (x <= 1) {
+            return x;
+        }
+
+        int l = 1;
+        int r = x;
+        int result = 0;
+
+        while (l <= r) {
+            int mid = (l + r) / 2;
+            if (mid <= x / mid) {
+                l = mid + 1;
+                result = mid;
+            } else {
+                r = mid - 1;
+            }
+        }
+        return result;
+    }
 }
-
+

src/main/java/com/fibers/algorithm/leetcode/_081/Solution.java

@@ -1,4 +1,35 @@
 package com.fibers.algorithm.leetcode._081;
+
 public class Solution {
+    public boolean search(int[] nums, int target) {
+        if (nums == null || nums.length == 0) {
+            return false;
+        }
+        int start = 0;
+        int end = nums.length - 1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (nums[mid] == target) {
+                return true;
+            }
+
+            if (nums[mid] < nums[end] || nums[mid] < nums[start]) {
+                if (nums[mid] < target && target <= nums[end]) {
+                    start = mid + 1;
+                } else {
+                    end = mid - 1;
+                }
+            } else if (nums[mid] > nums[end] || nums[mid] > nums[start]) {
+                if (nums[mid] > target && target >= nums[start]) {
+                    end = mid - 1;
+                } else {
+                    start = mid + 1;
+                }
+            } else {
+                end--;
+            }
+        }
+        return false;
+    }
 }
-
+

src/main/java/com/fibers/algorithm/leetcode/_113/Solution.java

@@ -1,4 +1,33 @@
 package com.fibers.algorithm.leetcode._113;
+
+import com.fibers.algorithm.datastructure.TreeNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
 public class Solution {
+    public List<List<Integer>> pathSum(TreeNode root, int sum) {
+        List<List<Integer>> result = new ArrayList<>();
+        backtracking(result, new ArrayList<>(), root, sum);
+        return result;
+    }
+
+
+    private void backtracking(List<List<Integer>> result, List<Integer> list, TreeNode root, int sum) {
+        if (root == null) {
+            return;
+        }
+
+        list.add(root.val);
+
+        if(root.left == null && root.right == null && sum == root.val){
+            result.add(new ArrayList<>(list));
+
+        }else{
+            backtracking(result, list, root.left, sum - root.val);
+            backtracking(result, list, root.right, sum - root.val);
+        }
+        list.remove(list.size() - 1);
+    }
 }
-
+

src/main/java/com/fibers/algorithm/leetcode/_153/Solution.java

@@ -1,4 +1,19 @@
 package com.fibers.algorithm.leetcode._153;
+
 public class Solution {
+    public int findMin(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return -1;
+        }
+
+        int i = 1;
+        for (; i < nums.length; i++) {
+            if (nums[i] < nums[i - 1]) {
+                break;
+            }
+        }
+
+        return i == nums.length ? nums[0] : nums[i];
+    }
 }
-
+

src/main/java/com/fibers/algorithm/leetcode/_796/Solution.java

@@ -1,4 +1,8 @@
 package com.fibers.algorithm.leetcode._796;
+
 public class Solution {
+    public boolean rotateString(String A, String B) {
+        return A.length() == B.length() && (A + A).contains(B);
+    }
 }
-
+