2020-10-30每天一刷

力扣33 搜尋旋轉排序陣列

給你一個升序排列的整數陣列 nums ，和一個整數 target 。

假設按照升序排序的陣列在預先未知的某個點上進行了旋轉。（例如，陣列 [0,1,2,4,5,6,7] 可能變為 [4,5,6,7,0,1,2] ）。

請你在陣列中搜尋 target ，如果陣列中存在這個目標值，則返回它的索引，否則返回 -1 。

示例 1：

輸入：nums = [4,5,6,7,0,1,2], target = 0
輸出：4

示例 2：

輸入：nums = [4,5,6,7,0,1,2], target = 3
輸出：-1

示例 3：

輸入：nums = [1], target = 0
輸出：-1

提示：

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
nums 中的每個值都 獨一無二
nums 肯定會在某個點上旋轉
-10^4 <= target <= 10^4

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

思路：target == nums[mid] 就返回mid;通過nums[begin]和nums[mid]來區分那一部分是有序的，那一部分不是有序的，從而縮小搜素的範圍。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        if(!n){
            return -1;
        }
        if(n == 1){
            return target == nums[0] ? 0 : -1;
        }
        int begin =0;
        int end = nums.size()-1;
        while(begin <= end){//這裡取等號是因為閉區間
            int mid = begin + (end - begin) / 2;
            if(target == nums[mid]){
                return mid;
            }
            if(nums[begin] <= nums[mid]){//[3,1] target = 1時
                if(target >= nums[begin] && target < nums[mid]){//邊界值，要取等號
                    end = mid - 1;
                }
                else
                    begin = mid + 1;
            }
            else{
                if(target > nums[mid] && target <= nums[end]){//注意邊界值要取等號
                    begin = mid + 1;
                }
                else{
                    end = mid -1;
                }
            }
        }
        return -1;
    }
};

二叉排序樹

1. 左子樹不為空，怎左子樹上的所有節點的值均小於或者等於它的根節點的值；
2. 若右子樹不為空，則右子樹上所有節點的值均大於或者等於它的根節點的值；
3. 左右子樹也分別為二叉排序樹。
4. 等於的情況只能出現在左子樹或者右子樹中的某一側。
   二叉查詢樹的中序遍歷是從小到大的，故又名二叉排序樹。

二叉排序樹的建立

#include "util.h"
using namespace std;
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int  x):val(x),left(nullptr),right(nullptr){}
};
//在一個BST樹中插入一個新的節點
void BST_insert(TreeNode* node,TreeNode* insert_node){
    if (insert_node->val < node->val){
        if (node->left){
            BST_insert(node->left,insert_node);
        }
        else{
            node->left = insert_node;
        }
    }
    else{
        if (node->right){
            BST_insert(node->right,insert_node);
        }
        else{
            node->right = insert_node;
        }
    }
}
//前序列印BST樹
void preorder_print(TreeNode* node, int layer){
    if(!node){
        return;
    }
    for (int i = 0; i < layer; ++i) {
        printf("-----");
    }
    printf("%d\n",node->val);
    preorder_print(node->left,layer+1);
    preorder_print(node->right,layer+1);
}
//查詢某一節點是否在BST二叉樹中
bool BST_search(TreeNode* node, int value){
    if(node->val == value){
        return true;
    }
    if(value < node->val){
        if(node->left){
            BST_search(node->left,value);
        }
        return false;
    }
    else{
        if (node->right){
            BST_search(node->right,value);
        }
        else{
            return false;
        }
    }
}
int main(){
    //建一個根節點為8的樹
    TreeNode root(8);
    vector<TreeNode*> node_vec;
    int test[]= {3,10,1,6,15};
    for (int i = 0; i < 5; ++i) {
        node_vec.push_back(new TreeNode(test[i]));
    }
    for (int i = 0; i < node_vec.size(); ++i) {
        BST_insert(&root,node_vec[i]);
    }
    preorder_print(&root, 0);
    return 0;
}