代码随想录Day15:搜索二叉树

定义：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉搜索树

所以可以把搜索二叉树和中序遍历进行相结合得时候，那么此时遍历输出的数组就会是一个单调递增的数组，从而更好的帮忙解决关于搜索二叉树的题目

1.617合并二叉树

合并二叉树有两种方法：第一种方法就是新建一个二叉树，每个节点都是新建的，第二种是根据一个二叉树作为参考进行修改里面的值或者修改指向的结点从而完成合并的操作，第二种方法更加的节省时间和空间。

两种方法：第一种是递归调用，递归终止条件：当遇到的对应的结点有一个为空的时候返回另外一个结点。

第二种是使用迭代的方法进行操作：迭代的时候使用队列进行操作，每次将两个节点都入队，这样是为了保证对应的位置是相同的，然后确定是否存在左右节点，入队，有点类似于前面的层次遍历的方法，后面的两个if判断，是因为我们将root1作为返回的结点，所以如果存在root1不存在而root2存在的时候我们需要进行一个相应的更改结点的指向的位置。

    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        /*
        //使用递归的方法进行调用
        if(root1 == nullptr)return root2;
        if(root2 == nullptr)return root1;
        root1->val += root2->val;
        root1->left = mergeTrees(root1->left,root2->left);
        root1->right = mergeTrees(root1->right,root2->right);
        return root1;
        */
        //第二种方法：使用迭代的方法
        if(root1 == nullptr)return root2;
        if(root2 == nullptr)return root1;
        queue<TreeNode*> que;
        que.push(root1);
        que.push(root2);
        while(!que.empty()){
            TreeNode* node1 = que.front();que.pop();
            TreeNode* node2 = que.front();que.pop();
            node1->val += node2->val;
            if(node1->left!=nullptr&& node2->left!=nullptr){
                que.push(node1->left);
                que.push(node2->left);
            }
            if(node1->right!=nullptr&& node2->right!=nullptr){
                que.push(node1->right);
                que.push(node2->right);
            }
            if(node1->left == nullptr&&node2->left!=nullptr){
                node1->left = node2->left;
            }
            if(node1->right == nullptr&&node2->right!=nullptr){
                node1->right = node2->right;
            }
        }
        return root1;
    }

2.700二叉搜索树中的搜索

由于前面提到的二叉搜索树的性质，所以我们可以将迭代进行优化，直接判断结点移动的位置即可。

    TreeNode* searchBST(TreeNode* root, int val) {
        /*
        //第一种方法：使用递归的方法
        if(root == nullptr||root->val == val) return root;//找到或者到达了最下面，递归的终止条件
        if(root->val>val)return searchBST(root->left,val);
        if(root->val<val)return searchBST(root->right,val);
        return nullptr;
        */
        //第二种方法：根据搜索二叉树的性质来进行迭代
        while(root){
            if(root->val<val){
                root = root->right;
            }else if(root->val>val){
                root = root->left;
            }else{
                return root;
            }
        }
        return root;
    }

3.98验证搜索二叉树

相比于使用递归的方法，使用前面学到的中序遍历生成一个数组可能更加的熟练，只需要在最后判断一下这个新生成的数组是否是一个单调递增的即可。

    bool isValidBST(TreeNode* root) {
        //因为二叉搜索树的性质基本上和中序遍历相似，所以我们想要判断是否是二叉搜索树，可以直接套用前面的深度遍历里面的中序遍历即可
        stack<TreeNode*> st;
        vector<int> result;
        if(root != nullptr) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if(node!=nullptr){
                st.pop();
                if(node->right)st.push(node->right);
                st.push(node);
                st.push(nullptr);
                if(node->left)st.push(node->left);
            }else{
                st.pop();
                node = st.top();
                result.push_back(node->val);
                st.pop();
            }
        }
        for(int i = 1;i<result.size();i++){
            if(result[i-1]>=result[i]){
                return false;
            }
        }
        return true;
    }

4.530二叉搜索树的最小绝对值差

直接套用前面的生成那个递归序列的方式生成一个单调递增的数组，然后判断里面的最小差值即可。

    int getMinimumDifference(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if(root != nullptr) st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            if(node!=nullptr){
                st.pop();
                if(node->right)st.push(node->right);
                st.push(node);
                st.push(nullptr);
                if(node->left)st.push(node->left);
            }else{
                st.pop();
                node = st.top();
                result.push_back(node->val);
                st.pop();
            }
        }
        int mins = 100000;
        for(int i = 1;i<result.size();i++){
            if(result[i]-result[i-1]<mins){
                mins = result[i]-result[i-1];
            }
        }
        return mins;
    }