[Function add]

Seanforfun · Seanforfun · commit fe9736cc1df1 · 2019-04-10T14:33:00.000-04:00
1. Add leetcode solutions with tag binary search.
diff --git a/leetcode/153. Find Minimum in Rotated Sorted Array.md b/leetcode/153. Find Minimum in Rotated Sorted Array.md
@@ -85,3 +85,22 @@ class Solution {
     }
 }
 ```
+
+### Third Time
+* Method 1: Binary search
+	```Java
+	class Solution {
+		public int findMin(int[] nums) {        
+			return search(nums, 0, nums.length - 1);
+		}
+		private int search(int[] nums, int low, int high){
+			if(low >= high) return nums[low];
+			int mid = low + (high - low) / 2;
+			if(nums[mid] >= nums[low]){
+				return Math.min(nums[low], search(nums, mid + 1, high));
+			}else{
+				return Math.min(nums[mid], search(nums, low, mid - 1));
+			}
+		}
+	}
+	```
diff --git a/leetcode/154. Find Minimum in Rotated Sorted Array II.md b/leetcode/154. Find Minimum in Rotated Sorted Array II.md
@@ -101,4 +101,22 @@ class Solution {
             return Math.min(nums[mid], find(nums, low + 1, mid - 1));
     }
 }
-```
+```
+
+### Fourth Time
+* Method 1: binary search
+	```Java
+	class Solution {
+		public int findMin(int[] nums) {
+			return findMin(nums, 0, nums.length - 1);
+		}
+		private int findMin(int[] nums, int low, int high){
+			if(low >= high) return nums[low];
+			int mid = low + (high - low) / 2;
+			while(low < mid && nums[low] == nums[mid]) low++;
+			while(high > mid && nums[high] == nums[mid]) high--;
+			if(nums[mid] >= nums[low]) return Math.min(nums[low], findMin(nums, mid + 1, high));
+			else return Math.min(nums[mid], findMin(nums, low, mid - 1));
+		}
+	}
+	```
diff --git a/leetcode/162. Find Peak Element.md b/leetcode/162. Find Peak Element.md
@@ -83,5 +83,22 @@ class Solution {
 }
 ```
 
+### Third Time
+* Method 1: Binary Search
+	```Java
+	class Solution {
+		public int findPeakElement(int[] nums) {
+			if(nums.length == 1) return 0;
+			int low = 0, high = nums.length - 1;
+			while(low < high){
+				int mid = low + (high - low) / 2;
+				if(nums[mid] < nums[mid + 1]) low = mid + 1;
+				else high = mid;
+			}
+			return low;
+		}
+	}
+	```
+
 ### Reference
 1. [leetcode 162. Find Peak Element-查找峰元素|二分查找](https://blog.csdn.net/happyaaaaaaaaaaa/article/details/51590056)
diff --git a/leetcode/33. Search in Rotated Sorted Array.md b/leetcode/33. Search in Rotated Sorted Array.md
@@ -116,4 +116,27 @@ class Solution {
         return -1;
     }
 }
-```
+```
+
+### Third Time
+* Method 1: Binary search: AC 100%
+	```Java
+	class Solution {
+		public int search(int[] nums, int target) {
+			if(nums == null || nums.length == 0) return -1;
+			return search(nums, 0, nums.length - 1, target);
+		}
+		private int search(int[] nums, int low, int high, int target){
+			int mid = low + (high - low) / 2;
+			if(low > high) return -1;
+			if(nums[mid] == target) return mid;
+			else if(nums[mid] >= nums[low]){    //left is in order
+				if(target >= nums[low] && target < nums[mid]) return search(nums, low, mid - 1, target);
+				else return search(nums, mid + 1, high, target);
+			}else{  //right is in order
+				if(target > nums[mid] && target <= nums[high]) return search(nums, mid + 1, high, target);
+				else return search(nums, low, mid - 1, target);
+			}
+		}
+	}
+	```
diff --git a/leetcode/81. Search in Rotated Sorted Array II.md b/leetcode/81. Search in Rotated Sorted Array II.md
@@ -79,3 +79,28 @@ class Solution {
     }
 }
 ```
+
+### Third Time
+* Method 1: binary search, I get the answer by myself
+	```Java
+	class Solution {
+		public boolean search(int[] nums, int target) {
+			if(nums == null || nums.length == 0) return false;
+			return search(nums, 0, nums.length - 1, target);
+		}
+		private boolean search(int[] nums, int low, int high, int target){
+			if(low > high) return false;
+			int mid = low + (high - low) / 2;
+			if(nums[mid] == target) return true;
+			while(low < mid && nums[low] == nums[mid]){low++;}
+			while(high > mid && nums[high] == nums[mid]){high--;}
+			if(nums[mid] >= nums[low]){    // left side is in order
+				if(target >= nums[low] && target < nums[mid]) return search(nums, low, mid - 1, target);
+				else return search(nums, mid + 1, high, target);
+			}else{ //right side is in order
+				if(target > nums[mid] && target <= nums[high]) return search(nums, mid + 1, high, target);
+				else return search(nums, low, mid - 1, target);
+			}
+		}
+	}
+	```
diff --git a/leetcode/852. Peak Index in a Mountain Array.md b/leetcode/852. Peak Index in a Mountain Array.md
@@ -0,0 +1,44 @@
+## 852. Peak Index in a Mountain Array
+
+### Question:
+Let's call an array A a mountain if the following properties hold:
+* A.length >= 3
+* There exists some 0 < i < A.length - 1 such that A[0] < A[1] < ... A[i-1] < A[i] > A[i+1] > ... > A[A.length - 1]
+
+Given an array that is definitely a mountain, return any i such that A[0] < A[1] < ... A[i-1] < A[i] > A[i+1] > ... > A[A.length - 1].
+
+```
+Example 1:
+
+Input: [0,1,0]
+Output: 1
+
+Example 2:
+
+Input: [0,2,1,0]
+Output: 1
+```
+
+Note:
+1. 3 <= A.length <= 10000
+2. 0 <= A[i] <= 10^6
+3. A is a mountain, as defined above.
+
+
+### Solution:
+* Method 1: Binary search
+    ```Java
+    class Solution {
+        public int peakIndexInMountainArray(int[] A) {
+            int low = 0, high = A.length - 1;
+            while(low < high){
+                int mid = low + (high - low) / 2;
+                if(A[mid] < A[mid + 1]) low = mid + 1;
+                else high = mid;
+            }
+            return low;
+        }
+    }
+    ```
+    
+   
