二叉搜索树BST

Posted mini-coconut

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了二叉搜索树BST相关的知识,希望对你有一定的参考价值。

二叉搜索树,也称有序二叉树,排序二叉树,是指一棵空树或者具有下列性质的二叉树:

1. 若任意节点的左子树不空,则左子树上所有结点的值均小于它的根结点的值;

2. 若任意节点的右子树不空,则右子树上所有结点的值均大于它的根结点的值;

3. 任意节点的左、右子树也分别为二叉查找树。

4. 没有键值相等的节点。

通过中序遍历可以得到一个有序数列。一个无序序列可以通过构造一棵二叉排序树变成一个有序序列,构造树的过程即为对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点,在进行插入操作时,不必移动其它结点,只需改动某个结点的指针,由空变为非空即可。搜索,插入,删除的复杂度等于树高,O(log(n)).

(1)BST的建立

首先需要建立一个节点Node的结构体,这个结构体表示每个Node节点包括数值,左孩子,右孩子。当然一般还加上一个构造函数用于后面的初始化。

struct Node
{
    int val;
    Node* left;
    Node* right;
    Node( const int& value)  :left(NULL)  ,right(NULL)  ,val(value)  {}  
};

另外我们就要像新建一个链表一样来完成一个二叉搜索树的创建。这里采用的是每输入一个值,以-1作为结束,就调用插入函数Insert(这个函数自己定义实现,后面会说),Insert函数会将这个节点连接到它该在的位置。Insert函数需要的参数是root根节点和插入的值value的值。注意这里root根节点要用引用传递,否则我每次调用完函数,root节点不变。

Node* creatBST()
{
    Node *root;
    root=NULL;
    int a;
    cin>>a;
    while(a!=-1)
    {
        Insert(root,a);
         cin>>a;
    }
    return root;
}

(2)BST的输出

我们利用BST的性质,因为BST的中序遍历就是一个有序的数列,所以我们输出用中序遍历来检测我们的程序结果。

void _InOrder(const Node* root)  
{
    if (root == NULL)
      return;  
  _InOrder(root->left);  
  cout << root->val << " ";
  _InOrder(root->right);  
}

这里采用的是递归形式的中序遍历。非递归形式,需要大家去学习,我前面有总结过。

(3)BST的插入

插入的操作很简单,有递归和非递归(迭代)两种实现方法。我们首先总结BST插入的迭代实现方法。

首先我们要明白,BST的插入永远是插入到叶子节点的后面,所以不会出现插入到中间的情况,我们只需要去比较每个节点的值和当前需要插入的值的大小,就能找到正确的插入位置。这里用两个Node型的指针,cur指向当前位置,parent指向当前位置的父节点。cur负责找到要插入的位置,parent负责插入的实现。

bool Insert(Node* &root,const int& value)  
{  
    if (root == NULL)
    {  
        root = new Node(value);  
    }  
    Node* cur=root;  
    Node* parent = NULL;  
    //首先找到要插入的位置  
    while (cur)  
    {  
        if (cur->val > value)  
        {  
            parent = cur;  
            cur = cur->left;  
        }  
        else if(cur->val<value)  
        {  
            parent = cur;  
            cur = cur->right;  
        }  
        else  
        {  
            return false;  
        }  
    }  
    //在找到插入位置以后,判断插入父亲节点的左边还是右边  
    if (parent->val > value)  
    {  
        parent->left = new Node(value);  
    }  
    else  
    {  
        parent->right = new Node(value);  
    }  
    return true;  
}

递归形式也很简单

bool Insert(Node*& root, const int& value)  
{  
    if (root == NULL)  
    {  
        root = new Node(value);  
        return true;  
    }  
    if (root->val > value)  
    {  
        return Insert(root->left, value);  
    }  
    else if(root->val < value)  
    {  
        return Insert(root->right,value);  
    }  
    else  
    {  
        return false;  
    }  
}  

(3)BST的删除操作

BST的删除是最复杂的,之所以复杂,是因为要分几种情况。所以我们只要弄清楚删除一个节点的逻辑,程序的实现自然不难。

二叉搜索树的删除:

技术分享图片

主要分三大种情况,(1)如果要删除的节点只有左子树,那么就将该节点的父节点指向该节点的左子树,删除该节点就好了

(2)如果要删除的节点只有右子树,那么就将该节点的父节点指向该节点的右子树,删除该节点就好了

(3)如果要删除的节点左右子树都有,那么就要找比该节点的左节点要大一个数的节点,这个时候自然不能直接将右子树直接提上去,所以我们要找该节点右子树的最左孩子,也就是右子树中序遍历的第一个数。

bool Remove(Node* &root,const int& value)  
{  
    //没有节点  
    if (root == NULL)  
    {  
        return false;  
    }  
    //只有一个节点  
    if (root->left == NULL&&root->right == NULL)  
    {  
        if (root->val == value)  
        {  
            delete root;  
            root = NULL;  
            return true;  
        }  
        return false;  
    }  
  
    Node* parent = NULL;  
    Node* cur = root;  
    //遍历查找要删除节点的位置  
    while (cur)  
    {  
        Node* del = NULL;  
        if (cur->val > value)  
        {  
            parent = cur;  
            cur = cur->left;  
        }  
        else if (cur->val < value)  
        {  
            parent = cur;  
            cur = cur->right;  
        }  
        else  
        {  
            //要删除节点的左子树为空,分3种情况  
            if (cur->left == NULL)  
            {  
                //注意判断父节点是否为空,若为空,则要删除的节点为根节点
               /* if (parent == NULL)  
                {  
                    root = cur->right;  
                    delete cur;  
                    cur = NULL;  
                    return true;  
                }  */
                if (parent->val > cur->val)  
                {  
                    del = cur;  
                    parent->left = cur->right;  
                    delete del;  
                    return true;  
                }  
                else if (parent->val < value)  
                {  
                    del = cur;  
                    parent->right = cur->right;  
                    delete del;  
                    return true;  
                }  
            }  
            //要删除节点的右子树为空,同样分3种情况  
            else if (cur->right == NULL)  
            {  
                //注意判断父节点是否为空,若为空,则要删除的节点为根节点,如:只有根节点5和其左节点3  
             /*   if (parent == NULL)  
                {  
                    root = cur->left;  
                    delete cur;  
                    cur = NULL;  
                    return true;  
                }  */
                if (parent->val > cur->val)  
                {  
                    del = cur;  
                    parent->left = cur->left;  
                    delete del;  
                    return true;  
                }  
                else if (parent->val < cur->val)  
                {  
                    del = cur;  
                    parent->right = cur->left;  
                    delete del;  
                    return true;  
                }  
            }  
            //左右子树都不为空  
            else  
            {  
                Node* del = cur;  
                Node* parent = NULL;  
                Node* RightFirst = cur->right;  
                //右边第一个节点的左子树为空  
                if (RightFirst->left == NULL)  
                {  
                    swap(RightFirst->val, cur->val);  
                    del = RightFirst;
                    cur->right = RightFirst->right;  
                    delete del;  
                    return true;  
                }  
                //右边第一个节点的左子树不为空  
                while (RightFirst->left)  
                {  
                    parent = RightFirst;  
                    RightFirst = RightFirst->left;  
                }  
                   swap(RightFirst->val, cur->val);  
                   del = RightFirst;  
                   parent->left = RightFirst->right;  
                   delete del;  
                   return true;  
            }  
        }  
    }  
    return false;  
}  

递归形式也可以写

bool Remove(Node*& root, const int& value)  
{  
    //没有节点  
    if (root == NULL)  
    {  
        return false;  
    }  
    //只有一个节点  
    if (root->left == NULL&&root->right == NULL)  
    {  
        if (root->val == value)  
        {  
            delete root;  
            root = NULL;  
            return true;  
        }  
        else  
        {  
            return false;  
        }  
  
    }  
  
    //删除二叉搜索树节点的递归写法  
    if (root->val > value)  
    {  
        Remove(root->left, value);  
    }
    else if (root->val <value)  
    {  
        Remove(root->right, value);  
    }  
    else  
    {  
        Node* del = NULL;  
          
        if (root->left == NULL)  
        {  
            del = root;  
            root = root->right;  
            delete del;  
            del = NULL;  
            return true;  
        }  
        else if (root->right == NULL)  
        {  
            del = root;  
            root = root->left;  
            delete del;  
            del = NULL;  
            return true;  
        }  
        else  
        {  
            Node* RightFirst = root->right;  
  
            while (RightFirst->left)  
            {  
                RightFirst = RightFirst->left;  
            }  
  
            swap(root->val, RightFirst->_val);  
  
            Remove(root->right, value);  
            return true;  
        }  
    }  
}  

 

以上是关于二叉搜索树BST的主要内容,如果未能解决你的问题,请参考以下文章

C++ 实现二叉排序树(搜索树BST)(完整代码)

树--05---二叉树--02---二叉搜索树(BST)遍历

二叉搜索树(BST)---python实现

python实现二叉搜索树_二叉搜索树(BST)---python实现

树--04---二叉树--01---简介二叉搜索树(BST)实现

[leetcode]450. Delete Node in a BST二叉搜索树删除节点