数据结构---【二叉搜索树】

必须满足的条件：左子树中所有节点的值< 根节点的值  < 右子树中所有节点的值

任意节点的左右子树也是搜索二叉树，也要满足上面的条件

二叉搜索树与堆不同，不一定是完全二叉树，采用链式结构

搜索二叉树的中序遍历是升序

 1、查找 

数据大于根 往右走 小于根往左走

TreeNode* search(BinarySearchTree* bst,int num)
{
    TreeNode* cur = bst->root;
    while(cur != NULL)
    {
        if(cur->data < num)
        {    cur = cur -> right; }
        else{ cur= cur -> left;}
        else  break; 
    }
    return cur;
}

2、插入节点

    //1、判断树是否为空 为空创建节点 把数据放入
    //2、树不为空 首先判断 这个要插入的数据是否重复 重复直接返回，cur指向要插入数据的位置 perv指向要插入数据的父亲节点
    //3、找到位置
    //4、将父亲的左/右指向插入的数据节点（看num的值大于prev->data还是小于，大于就是right指向node，小于就是left

void insert(BinarySearchTree* bst, int num)
{
    //1、判断树是否为空 为空创建节点 把数据放入
    //2、树不为空 首先判断 这个要插入的数据是否重复 cur指向要插入数据的位置 perv指向要插入数据的父亲节点
    //3、找到位置
    //4、将父亲的左/右指向插入的数据节点
    if(bst -> root = NULL)
    {
        bst->root = newTreeNode(num);//创建新节点 把数据放进去
        return;
    }
    TreeNode* cur = bst->root, *prev = NULL;
    while(cur != NULL) //等于NULL不能再进入循环
    {
        if(cur->data = num)
        { return; }
        prev = cur;
        if(cur -> data < num)
        { cur = cur -> right; }
        else { cur = cur ->left;}
    }
    TreeNode* node = newTreeNode(num);
    if(prev -> data < num)
    { prev ->right = node;}
    else { prev -> left = node;}
}

3、删除节点

1、找到要删除的节点 

2、看节点的度   

节点度为0/1：让要被删除的节点的父亲节点指向要被删除的节点的孩子 

节点度为2：找替换节点；找左子树中的最大的或者右子树中的最小的。

查找cur在中序遍历中的下一个节点（即右子树的最小值）；将找到的这个节点删除；将删除节点的值赋值给cur的值。

void removeItem(BinarySearchTree* bst, int num)
{
    if(bst -> root == NULL)
    { return;}
    TreeNode* cur = bst->root, *prev = NULL;
    while(cur != NULL) //cur可以指向空，只是指向空之后就不能再进入循环了
    {
        if(cur->data = num)  break;
        prev = cur;
        if(cur -> data < num)
        { cur = cur -> right;}
        else { cur = cur -> left;}
    }
    if(cur == NULL) return; //没有找到要删除的值 直接退出
    if(cur->left == NULL || cur->right == NULL)
    {    TreeNode* child = cur ->left != NULL ? cur->left : cur->right;
         if(pre->right == cur){pre ->right = child;}
         else{ pre->left =child;}
         free(cur);
    }
    else{   
            TreeNode* tmp = cur->right;
            while(tmp->left !=NULL)
            {tmp = tmp -> left;}
            int tmpval = tmp->data;
            removeItem(bst,tmp->val);//删除找到的右子树的最小值
            cur -> data = tmpval;
        }
}   

class Solution {
public:
    bool isValidBSTHelp(struct TreeNode* root,long min_val, long max_val)
    {
        if(root == NULL)  return true;//空树也是BST
        if(root->val <= min_val || root->val >= max_val) 
        return false; //树根的值必须在这个范围内
        //根的值是左子树的上界 是右子树的下界 两个同时满足才可返回true
        return isValidBSTHelp(root->left,min_val,root->val)&&
            isValidBSTHelp(root->right,root->val,max_val);
    }
    bool isValidBST(TreeNode* root)
    {
        return isValidBSTHelp(root,LONG_MIN,LONG_MAX);//两个宏值
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

 //从根节点开始遍历
 //如果插入的值大于根往右走，判断根的右是不是为空
 //为空直接建节点就让pos->right = val
 //走一步判断右（pos->right）是否为空，为空就pos->right = val
 //左边也是同理

struct TreeNode* creatTreeNode(int val) {
    struct TreeNode* ret = malloc(sizeof(struct TreeNode));
    ret->val = val;
    ret->left = ret->right = NULL;
    return ret;
}
struct TreeNode* insertIntoBST(struct TreeNode* root, int val) {
    if (root == NULL) {
        root = creatTreeNode(val);
        return root;
    }
    struct TreeNode* pos = root;//指向根
    while (pos != NULL) {
        if (val < pos->val) { //往左走
            if (pos->left == NULL) { //看左边是不是为空
                pos->left = creatTreeNode(val); //为空直接链入左子树
                break;
            } else {
                pos = pos->left; //左不为空继续往左走
            }
        } else {
            if (pos->right == NULL) {
                pos->right = creatTreeNode(val);
                break;
            } else {
                pos = pos->right;
            }
        }
    }
    return root;
}

 

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        TreeNode *cur = root, *curParent = nullptr;
        while (cur && cur->val != key) {
            curParent = cur;
            if (cur->val > key) {
                cur = cur->left;
            } else {
                cur = cur->right;
            }
        }
        if (!cur) {
            return root;
        }
        if (!cur->left && !cur->right) {
            cur = nullptr;
        } else if (!cur->right) {
            cur = cur->left;
        } else if (!cur->left) {
            cur = cur->right;
        } else {
            TreeNode *successor = cur->right, *successorParent = cur;
            while (successor->left) {
                successorParent = successor;
                successor = successor->left;
            }
            if (successorParent->val == cur->val) {
                successorParent->right = successor->right;
            } else {
                successorParent->left = successor->right;
            }
            successor->right = cur->right;
            successor->left = cur->left;
            cur = successor;
        }
        if (!curParent) {
            return cur;
        } else {
            if (curParent->left && curParent->left->val == key) {
                curParent->left = cur;
            } else {
                curParent->right = cur;
            }
            return root;
        }
    }
};