算法-搜索二叉树

最新推荐文章于 2024-10-10 22:59:02 发布

f_l_o_u_r

最新推荐文章于 2024-10-10 22:59:02 发布

阅读量103

点赞数 1

文章标签：算法

本文链接：https://blog.csdn.net/f_l_o_u_r/article/details/125379776

版权

一、知识点介绍

二叉搜索树的定义

空树是二叉搜索树；
若它的左子树不为空，则左子树上所有节点的值都小于它根节点的值；
若它的右子树不为空，则右子树上所有节点的值都大于它根节点的值；
它的左右子树均为二叉搜索树。

二叉搜索树的先序遍历

        给定一个某二叉搜索树的先序遍历序列，构造出一颗二叉搜索树
        1. 首先，考虑先序遍历的访问顺序：根节点->左子树->右子树，所以第一个节点一定是根节点；
        2. 然后，数组往后遍历的过程中，遇到的所有小于当前根节点的节点，都必然是左子树上的节点，后面的节点必然是右子树的节点；
        3. 如果检测到后面的节点有比当前根节点小的，则这个序列无法构造出一颗二叉搜索树；
        4. 遍历找到左右子树的分界点后，就可以进行左右子树递归计算了，注意递归时返回构造完的子树的根节点。

二叉搜索树的中序遍历

这个时最常用的，一颗二叉搜索树的中序遍历就是一个递增序列，可以在有效的时间内找出这棵树的第k大节点。

二叉搜索树的后序遍历

        给定一个某二叉搜索树的后序遍历序列，构造出一颗二叉搜索树
        1. 首先，考虑先序遍历的访问顺序：左子树->右子树->根节点，所以这个序列的最后一个节点一定是根节点；
        2. 然后，数组往前遍历的过程中，遇到的所有小于当前根节点的节点，都必然是左子树上的节点，后面的节点必然是右子树的节点；
        3. 如果检测到前面的节点有比当前根节点小的，则这个序列无法构造出一颗二叉搜索树；
        4. 遍历找到左右子树的分界点后，就可以进行左右子树递归计算了，注意递归时返回构造完的子树的根节点。

二、练习题目

        (1) 700. 二叉搜索树中的搜索
        (2) 剑指 Offer 54. 二叉搜索树的第k大节点
        (3) 701. 二叉搜索树中的插入操作
        (4) 面试题 04.05. 合法二叉搜索树

三、算法思路

1. 二叉搜索树中的搜索

(1) 根据二叉搜索树的特点，每次都把目标值和根节点的值进行对比，如果目标值大于根节点的值的话就往右子树递归搜索；如果目标值小于根节点的值的话就往左子树递归搜索；找到目标值就返回。
(2) 递归边界一个是找到目标值，一个是访问到了叶子结点就返回NULL。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root == NULL) return NULL;
        else if (root->val > val) return searchBST(root->left, val);
        else if (root->val < val) return searchBST(root->right, val);
        else return root;
    }
};

2. 二叉搜索树的第k大节点

(1) 通过中序遍历，把数据从小到大的存入ans数组中；
(2) 设数据集的大小为n，第k大的节点就是第（n-k）个数据

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    vector<int> ans;
    void inorder(struct TreeNode* root) {
        if(root) {
            inorder(root->left);
            ans.push_back(root->val);
            inorder(root->right);
        }
    }
public:
    int kthLargest(TreeNode* root, int k) {
        inorder(root);
        int n = ans.size();
        return ans[n-k];
    }
};

3. 二叉搜索树中的插入操作

        (1) 这道题的关键在于，需要插入的值在树中不存在；
        (2)和第一道题类似，判断需要插入的值和根节点的值的关系，如果val大于root->val向右子树递归遍历并更新左子树；如果val小于root->val向左子树递归遍历并更新右子树。因为val不在树中，所以在插入之前，树中不会有值等于val；
        (3) 递归边界是，当遍历到树的叶子节点的时候，插入val；这个时候新增的节点的值一定和题目给的val相等，跳出递归，返回答案。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == NULL) return new TreeNode(val);
        if(val < root->val) {
            root->left = insertIntoBST(root->left, val);
        }else if(val > root->val) {
            root->right = insertIntoBST(root->right, val);
        }
        return root;

    }
};

4. 合法二叉搜索树

(1) 这道题和第二道题类似，判断一颗二叉树是不是合法的二叉搜索树的关键是，在中序遍历中，是不是所有节点的值都是从小到大排序的。
(2) 用一个变量pre去存储上一次遍历到的节点的值，和现在遍历到的节点的值进行对比，现在遍历到的节点的值大于pre的话就合理；否则就不合理。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    #define INTI 32423432
    bool flag;
    int pre;
    void inorder(TreeNode* root) {
        if(root) {
            inorder(root->left);
            if(pre != INTI && root->val <= pre) {
                flag = false;
            }
            pre = root->val;
            inorder(root->right);
        }
    }
public:
    bool isValidBST(TreeNode* root) {
        pre = INTI;
        flag = true;
        inorder(root);
        return flag;
    }
};