11.11树Ⅵ

6.22二叉搜索树的插入操作

class Solution {
public:
    TreeNode* parent;//保存待插入结点的父节点
    void traversal(TreeNode* bt,int val){
        if(!bt){//bt根节点不存在，但是其父节点parent可能存在
            TreeNode* node = new TreeNode(val);
            if(val > parent->val) 
                parent->right = node;
            else 
                parent->left = node;
            return;
        }
        parent = bt;
        if(bt->val<val) 
            traversal(bt->right,val);
        if(bt->val>val)
            traversal(bt->left,val);
        return;
    }

    TreeNode* insertIntoBST(TreeNode* root, int val) {
        parent = new TreeNode(0);
        if(!root){
            root = new TreeNode(val);
            return root;
        }
        traversal(root,val);
        return root;    
    }
};

6.23删除二叉搜索树中的结点

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(!root) return root;//第一种根节点不存在
        if(root->val==key){
            if(!root->left&&!root->right){//第二，根节点是叶子结点
                delete root;
                return NULL;
            }

            else if(!root->left){//第三，根节点左子树不存在，直接将右子树返回 
                auto reroot = root->right;
                delete root;
                return reroot;
            }

            else if(!root->right){
                auto reroot = root->left;
                delete root;
                return reroot;
            }

            else{//第五，左右子树都存在。这里统一将右子树移动到当前的根节点，然后将左子树放入右子树最左结点的左子树上
                TreeNode* cur = root->right;//cur保存右子树最左结点
                while(cur->left)
                    cur = cur->left;
                TreeNode* tmp = root;
                cur->left = root->left;//将root左子树放在cur的左边
                root = root->right;//跟新root结点为右子树根节点
                delete tmp;
                return root;
            }
        }
        if(root->val < key) root->right = deleteNode(root->right,key);
        if(root->val > key) root->left = deleteNode(root->left,key);
        return root;
    }
};

6.24修剪二叉搜索树

class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(!root)
            return NULL;
        if(root->val<low){//根节点小于下限low，则返回根节点的右子树
            TreeNode* right = trimBST(root->right,low,high);
            return right;
        }
        if(root->val>high){
            TreeNode* left = trimBST(root->left,low,high);
            return left;
        }
        root->left = trimBST(root->left,low,high);//返回右子树，连接到其父节点的左子树
        root->right = trimBST(root->right,low,high);
        return root;
    }
};

6.25将有序数组转换为二叉搜索树

class Solution {
public:
    TreeNode* traversalbuild(vector<int>& nums,int left,int right){
        if(left>right) return NULL;
        int mid = (left+right)/2;
        TreeNode* cur = new TreeNode(nums[mid]);//将中间值或者中间偏左值当成根节点
        cur->left = traversalbuild(nums,left,mid-1);//左子树构建
        cur->right = traversalbuild(nums,mid+1,right);
        return cur;
    }

    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = traversalbuild(nums,0,nums.size()-1);//high下标为长度减一
        return root;
    }
};

6.26把二叉搜索树转换为累加树

class Solution {//右中左遍历
public:
    int pre = 0;//记录前一个cur->val
    void traversal(TreeNode* cur){
        if(!cur) return ;
        traversal(cur->right);
        cur->val += pre;
        pre = cur->val;
        traversal(cur->left);

    }

    TreeNode* convertBST(TreeNode* root) {
        traversal(root);
        return root;
    }
};