binary op questions

Author: da183

advanced_algorithm/binary_search_tree.md

@@ -12,47 +12,44 @@
 > 验证二叉搜索树
 
 ```c++
-class Solution {
-public:
-    struct Result {
-        TreeNode *maxNode;
-        TreeNode *minNode;
-        bool isValidate;
+struct Result {
+    TreeNode *maxNode;
+    TreeNode *minNode;
+    bool isValidate;
 
-        Result(bool validate = true, TreeNode *max = nullptr, TreeNode *min = nullptr)
-                : isValidate(validate), maxNode(max), minNode(min) {
+    Result(bool validate = true, TreeNode *max = nullptr, TreeNode *min = nullptr)
+            : isValidate(validate), maxNode(max), minNode(min) {
 
-        }
-    };
-    bool isValidBST(TreeNode *root) {
-        if (!root) {
-            return true;
-        }
-        return helper(root).isValidate;
-    }
-
-    Result helper(TreeNode *root) {
-        if (!root) {
-            return {};
-        }
-        auto left = helper(root->left);
-        auto right = helper(root->right);
-        if (!(left.isValidate && right.isValidate)) {
-            return {false};
-        }
-        if (left.maxNode && left.maxNode->val >= root->val) {
-            return {false};
-        }
-        if (right.minNode && right.minNode->val <= root->val) {
-            return {false};
-        }
-        return {
-                true,
-                right.maxNode ? right.maxNode : root,
-                left.minNode ? left.minNode : root,
-        };
     }
 };
+bool isValidBST(TreeNode *root) {
+    if (!root) {
+        return true;
+    }
+    return helper(root).isValidate;
+}
+
+Result helper(TreeNode *root) {
+    if (!root) {
+        return {};
+    }
+    auto left = helper(root->left);
+    auto right = helper(root->right);
+    if (!(left.isValidate && right.isValidate)) {
+        return {false};
+    }
+    if (left.maxNode && left.maxNode->val >= root->val) {
+        return {false};
+    }
+    if (right.minNode && right.minNode->val <= root->val) {
+        return {false};
+    }
+    return {
+            true,
+            right.maxNode ? right.maxNode : root,
+            left.minNode ? left.minNode : root,
+    };
+}
 ```
 
 [insert-into-a-binary-search-tree](https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/)

basic_algorithm/binary_search.md

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