二叉搜索树

应用

BST通过优先级来构建一棵树，有利于我们系统的架构时，根据具体框架的优先级来便于构建系统的结构树，方便我们的查找和插入。

性质

• 左子树的元素均小于根节点
• 右子树的元素均大于根节点
• 左右子树均为二叉搜索树
  和堆的结构类似，只不过根和子树的大小关系的不同，但均是通过元素的大小关系来构建树的整体结构

查找

查找某个元素，我们可以通过既有的元素的大小关系来简化搜索的过程。

Position Find( ElementType X, BinTree BST )
{
	if( !BST ) return NULL; /*查找失败*/
	if( X > BST->Data )
		return Find( X, BST->Right ); /*在右子树中继续查找*/
	else if( X < BST->Data )
		return Find( X, BST->Left ); /*在左子树中继续查找*/
	else /* X == BST->Data */
		return BST; /*查找成功，返回结点的找到结点的地址*/
}

插入

BinTree Insert( BinTree BST, ElementType X )
{
    if( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    }
    else { /* 开始找要插入元素的位置 */
        if( X < BST->Data )
            BST->Left = Insert( BST->Left, X );   /*递归插入左子树*/
        else  if( X > BST->Data )
            BST->Right = Insert( BST->Right, X ); /*递归插入右子树*/
        /* else X已经存在，什么都不做 */
    }
    return BST;
}

习题

验证二叉搜索树

98. 验证二叉搜索树 - 力扣（LeetCode）

解法一：验证该节点和子树之后再判断整个左子树和右子树的大小是否符合要求。

    bool isValidBST(TreeNode* root) {
        if(!root) return true;
        if((root->left!=nullptr&&root->val<=root->left->val)||(root->right!=nullptr&&root->val>=root->right->val)) return false;
        if(!isValidBST(root->left)||!isValidBST(root->right)) return false;
        if((root->left!=nullptr&&maxx(root->left)>=root->val)||(root->right!=nullptr&&minn(root->right)<=root->val)) return false;
        return true;
    }
    int maxx(TreeNode* node)
    {
        int ans=node->val;
        if(!node) return 0;
        if(node->left!=nullptr) ans=max(ans,maxx(node->left));
        if(node->right!=nullptr) ans=max(ans,maxx(node->right));
        return ans;
    }
    int minn(TreeNode* node )
    {
        int ans=node->val;
        if(!node) return 0;
        if(node->left!=nullptr) ans=min(ans,minn(node->left));
        if(node->right!=nullptr) ans=min(ans,minn(node->right));
        return ans;
    }

解法二：中序遍历。利用BST树之间的大小关系，我们可以得到中序遍历后的序列是一个单调的上升序列。

巧妙地利用中序遍历将大小关系转换为线性结构中的序的问题

bool isValidBST(TreeNode* root) {
        stack<TreeNode*> stack;
        long long inorder = (long long)INT_MIN - 1;

        while (!stack.empty() || root != nullptr) {
            while (root != nullptr) {
                stack.push(root);
                root = root -> left;
            }
            root = stack.top();
            stack.pop();
            // 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if (root -> val <= inorder) {
                return false;
            }
            inorder = root -> val;
            root = root -> right;
        }
        return true;
    }

构造二叉搜索树

由严格的单调的数组变化为平衡的二叉搜索树-->分治思想，每次取中间的mid，将其分为两段，再由其去分配。由于我们是取中间的，导致我们最后所得的树的结构必为平衡的结构。

 TreeNode* sortedArrayToBST(vector<int>& nums) {
        return BST(0,nums.size()-1,nums);
    }
    TreeNode* BST(int l,int r,vector<int>& nums)
    {
        if(l==r)
        {
            TreeNode* node=new TreeNode(nums[l]);
            return node;
        }
        if(r<l) return nullptr;
        int mid = l+r>>1;
        TreeNode* node=new TreeNode(nums[mid],BST(l,mid-1,nums),BST(mid+1,r,nums));
        return node;
    }