代码提交

Author: da183

Diff for: basic_algorithm/binary_search.md

@@ -266,27 +266,33 @@ int findMin(vector<int>& nums) {
 > 请找出其中最小的元素。(包含重复元素)
 
 ```c++
-int findMin(vector<int> &nums) {
-    if (nums.empty()) {
-        return -1;
+func findMin(nums []int) int {
+    // 思路：跳过重复元素，mid值和end值比较，分为两种情况进行处理
+    if len(nums) == 0 {
+        return -1
     }
-    auto left = 0;
-    auto right = nums.size() - 1;
-    while (left + 1 < right) {
-        while (left < right && nums[right] == nums[right - 1]) {
-            --right;
+    start := 0
+    end := len(nums) - 1
+    for start+1 < end {
+        // 去除重复元素
+        for start < end && nums[end] == nums[end-1] {
+            end--
         }
-        while (left < right && nums[left] == nums[left + 1]) {
-            ++left;
+        for start < end && nums[start] == nums[start+1] {
+            start++
         }
-        auto mid = left + (right - left) / 2;
-        if (nums[mid] <= nums[right]) {
-            right = mid;
+        mid := start + (end-start)/2
+        // 中间元素和最后一个元素比较（判断中间点落在左边上升区，还是右边上升区）
+        if nums[mid] <= nums[end] {
+            end = mid
         } else {
-            left = mid;
+            start = mid
         }
     }
-    return (nums[left] >= nums[right]) ? nums[right] : nums[left];
+    if nums[start] > nums[end] {
+        return nums[end]
+    }
+    return nums[start]
 }
 ```
 
@@ -297,40 +303,41 @@ int findMin(vector<int> &nums) {
 > 搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回  -1 。
 > 你可以假设数组中不存在重复的元素。
 
-```c++
-int search(vector<int> &nums, int target) {
-    if (nums.empty()) {
-        return -1;
+```go
+func search(nums []int, target int) int {
+    // 思路：/ / 两条上升直线，四种情况判断
+    if len(nums) == 0 {
+        return -1
     }
-    auto left = 0;
-    auto right = nums.size() - 1;
-    while (left + 1 < right) {
-        auto mid = left + (right - left) / 2;
-        if (nums[mid] == target) {
-            return mid;
+    start := 0
+    end := len(nums) - 1
+    for start+1 < end {
+        mid := start + (end-start)/2
+        // 相等直接返回
+        if nums[mid] == target {
+            return mid
         }
-        if (nums[left] < nums[mid]) {
-            if (nums[left] <= target && target <= nums[mid]) {
-                right = mid;
+        // 判断在那个区间，可能分为四种情况
+        if nums[start] < nums[mid] {
+            if nums[start] <= target && target <= nums[mid] {
+                end = mid
             } else {
-                left = mid;
+                start = mid
             }
-        } else if (nums[mid] < nums[right]) {
-            // 这个判断是必须的！当只有两个数的时候，可能两个都不满足！
-            if (target >= nums[mid] && nums[right] >= target) {
-                right = mid;
+        } else if nums[end] > nums[mid] {
+            if nums[end] >= target && nums[mid] <= target {
+                start = mid
             } else {
-                left = mid;
+                end = mid
             }
         }
     }
-    if (nums[left] == target) {
-        return left;
-    } else if (nums[right] == target) {
-        return right;
-    } else {
-        return -1;
+    if nums[start] == target {
+        return start
+    } else if nums[end] == target {
+        return end
     }
+    return -1
 }
 ```
 
@@ -344,39 +351,46 @@ int search(vector<int> &nums, int target) {
 > ( 例如，数组  [0,0,1,2,2,5,6]  可能变为  [2,5,6,0,0,1,2] )。
 > 编写一个函数来判断给定的目标值是否存在于数组中。若存在返回  true，否则返回  false。(包含重复元素)
 
-```c++
-bool search(vector<int>& nums, int target) {
-    if (nums.empty()) {
-        return false;
+```go
+func search(nums []int, target int) bool {
+    // 思路：/ / 两条上升直线，四种情况判断，并且处理重复数字
+    if len(nums) == 0 {
+        return false
     }
-    auto left = 0;
-    auto right = nums.size() - 1;
-    while (left + 1 < right) {
-        while (left < right && nums[left] == nums[left + 1]) {
-            ++left;
+    start := 0
+    end := len(nums) - 1
+    for start+1 < end {
+        // 处理重复数字
+        for start < end && nums[start] == nums[start+1] {
+            start++
         }
-        while (left < right && nums[right] == nums[right - 1]) {
-            --right;
+        for start < end && nums[end] == nums[end-1] {
+            end--
         }
-        auto mid = left + (right - left) / 2;
-        if (nums[mid] == target) {
-            return true;
+        mid := start + (end-start)/2
+        // 相等直接返回
+        if nums[mid] == target {
+            return true
         }
-        if (nums[left] < nums[mid]) {
-            if (nums[left] <= target && target <= nums[mid]) {
-                right = mid;
+        // 判断在那个区间，可能分为四种情况
+        if nums[start] < nums[mid] {
+            if nums[start] <= target && target <= nums[mid] {
+                end = mid
             } else {
-                left = mid;
+                start = mid
             }
-        } else if (nums[mid] < nums[right]) {
-            if (nums[mid] <= target && nums[right] >= target) {
-                left = mid;
+        } else if nums[end] > nums[mid] {
+            if nums[end] >= target && nums[mid] <= target {
+                start = mid
             } else {
-                right = mid;
+                end = mid
             }
         }
     }
-    return nums[left] == target || nums[right] == target;
+    if nums[start] == target || nums[end] == target {
+        return true
+    }
+    return false
 }
 ```