[数据结构与算法]算法笔记（8）：二叉搜索树

今天学了一种名为二叉搜索树的数据结构并自行实现了一番，写的过程发现了很多容易错的部分，现将其总结一下。

性质

1. 任意节点的键值大于其左子树上所有节点的键值，小于其右子数上所有节点的键值（一般二叉搜索树中不存在键值相同的节点）
2. 能够在O(logn)内做到删除、添加和查找节点
3. 一般用链表来存储

实现

自己写的代码

template <class _Ty>
struct treenode
{
    _Ty val;
    treenode<_Ty> *l;
    treenode<_Ty> *r;
    treenode(_Ty value)
    {
        val = value;
        l = NULL;
        r = NULL;
    }
};

template <class _Ty>
class bst
{
public:
    treenode<_Ty> *root;

    bst()
    {
        root = NULL;
    }
	
    treenode<_Ty> *find(treenode<_Ty> *node, _Ty val)
    {
        if (NULL == node)
            return NULL;
        if (val == node->val)
            return node;
        else
        {
            if (val > node->val)
                return find(node->r, val);
            else
                return find(node->l, val);
        }
    }

    void insert(treenode<_Ty> *node, _Ty val)
    {
        if (node == NULL)
        {
            root = new treenode<_Ty>(val);
            return;
        }
        if (val > node->val && node->r == NULL)
        {
            node->r = new treenode<_Ty>(val);
        }
        else if (val <= node->val && node->l == NULL)
        {
            node->l = new treenode<_Ty>(val);
        }
        else
        {
            if (val > node->val)
                insert(node->r, val);
            else
                insert(node->l, val);
        }
    }

    void build(const vector<_Ty> &a)
    {
        int sz = a.size();
        for (int i = 0; i < sz; i++)
        {
            insert(root, a[i]);
        }
    }

    bool del(_Ty val)
    {
        treenode<_Ty> *node_now = root, *node_past = NULL;
        bool right;
        while (1)
        {
            if (node_now == NULL)
                return false;
            else
            {
                if (val > node_now->val)
                {
                    node_past = node_now;
                    node_now = node_now->r;
                    right = 1;
                }
                else if (val < node_now->val)
                {
                    node_past = node_now;
                    node_now = node_now->l;
                    right = 0;
                }
                else
                    break;
            }
        }

        if (node_now->l == NULL && node_now->r == NULL)
        {
            if (node_past)
                right == 1 ? node_past->r = NULL : node_past->l = NULL;
            else
                root = NULL;
        }
        else if (node_now->l == NULL)
        {
            if (node_past)
                right == 1 ? node_past->r = node_now->r : node_past->l = node_now->r;
            else
                root = root->r;
        }
        else if (node_now->r == NULL)
        {
            if (node_past)
                right == 1 ? node_past->r = node_now->l : node_past->l = node_now->l;
            else
                root = root->l;
        }
        else
        {
            treenode<_Ty> *rmin = node_now->r, *rminp = node_now;
            while (rmin->l)
            {
                rminp = rmin;
                rmin = rmin->l;
            }

            if (node_past)
            {
                rminp->l == rmin ? rminp->l = rmin->r : rminp->r = rmin->r;
                right == 1 ? node_past->r = rmin : node_past->l = rmin;
                rmin->r = node_now->r;
                rmin->l = node_now->l;
            }
            else
            {
                rminp->l == rmin ? rminp->l = rmin->r : rminp->r = rmin->r;
                root = rmin;
            }
        }
        delete node_now;
        return true;
    }

    void Inorder_Traversal(treenode<_Ty> *node)
    {
        if (node == NULL)
            return;
        Inorder_Traversal(node->l);
        cout << node->val << " ";
        Inorder_Traversal(node->r);
    }
};

注意点

插入：插入一个节点不仅要找到可以插入该节点的位置，还需要该节点父节点的位置，插入过程一定要记得修改父节点左子树或者右子树的值
删除：我的代码删除过程写的较为复杂，但中心思路便是找到删除节点与其父节点，让其父节点指向另一个符合二叉树性质的节点，然后释放要删除的节点，这个过程有较多情况要考虑，所以实现起来比较复杂。

书上大佬的代码

struct node
{
    int val;
    node *l;
    node *r;

    node(int value)
    {
        val=value;
        l = NULL;
        r = NULL;
    }
};

node *insert(node *n, int val)
{
    if (n == NULL)
    {
        node *p = new node(val);
        return p;
    }
    else if (val > n->val)
    {
        n->r = insert(n->r, val);
    }
    else
    {
        n->l = insert(n->l, val);
    }
    return n;
}
node *find(node* n,int val)
{
    if(n==NULL)
        return NULL;
    
    if(n->val==val)
        return n;
    else if(val>n->val)
        return find(n->r, val);
    else
        return find(n->l, val);
}

node *del(node* n,int val)
{
    if(n==NULL)
    {
        return NULL;
    }
    else if(val>n->val)
    {
        n->r = del(n->r, val);
    }
    else if(val<n->val)
    {
        n->l = del(n->l, val);
    }
    else
    {
        if(!n->l)//没有左子树
        {
            node *p = n->r;
            delete n;
            return p;
        }
        else if(!n->l->r)//左子树没有右子树
        {
            //将n的右子树的值赋给n的左子树的右子树，让n的左子树替代n的位置，然后释放n
            node *p = n->l;
            p->r = n->r;
            delete n;
            return p;
        }
        else//其他情况
        {
            //用左子树上所有节点中键值最大的节点来替代n
            node *p = n->l;
            //p指向最大节点的前一个节点
            while(p->r->r)
            {
                p = p->r;
            }
            node *pr = p->r;
            p->r = pr->l;
            pr->l = n->l;
            pr->r = n->r;
            delete n;
            return pr;
        } 
    }
    return n;
}

巧妙的点

1. del函数的返回值为node*，使用这种方式避免了寻找删除节点父节点的麻烦，同时还不用特殊处理删除节点为根节点的情况，只要每次调用时让root=del(……)，如果删除点是根节点，则会返回新的根节点，否则返回原根节点。

大佬代码写的太好了，学习学习~