C++实现二叉排序树

#ifndef _TREENODE_H_
#define _TREENODE_H_
#define datatype int
#include <iostream>
using namespace std;
class BSTNODE
{
public:
    datatype key;
    BSTNODE* leftchild;
    BSTNODE* rightchild;
};
typedef BSTNODE* BSTtree;
BSTNODE* searchbst(BSTNODE* bst, datatype k)//查找非递归实现
{
    BSTNODE* q;
    q = bst;
    while (q)//当次课二叉排序不为空的时候，开始查找
    {
        if (q->key == k){
            return q;//当根节点的datatype就是要找的时候直接返回。
        }
        if (k < q->key){
            q = q->leftchild;
        }
        else
            q = q->rightchild;
    }

    return nullptr;//没找到
}

/*
BSTNODE* searchbst(BSTNODE* bst, datatype k)//查找的递归实现
{
if (!bst)return nullptr;//这棵树为空，不存在查找的必要
else if (bst->key == k){
return bst;
}
else if (bst->key > k){
return searchbst(bst->leftchild, k);
}
else{
return searchbst(bst->rightchild, k);
}
}
*/

void insertbst(BSTtree* bst, datatype k)//二叉排序树的插入
{
    BSTtree s;
    if ((*bst) == nullptr){
        s = (BSTtree)malloc(sizeof(BSTNODE));
        s->key = k;
        s->leftchild = nullptr;
        s->rightchild = nullptr;
        *bst = s;
    }
    else if (k < (*bst)->key){
        insertbst(&((*bst)->leftchild), k);
    }
    else{
        insertbst((&(*bst)->rightchild), k);
    }
}

void createbst(BSTtree *bst)//建立排序二叉树
{
    datatype key;
    *bst = nullptr;
    cout << "输入8个数字构造二叉排序树: ";
    for (int i = 0; i < 8; i++)
    {
        cin >> key;
        insertbst(bst, key);
    }
}

BSTNODE* del(BSTNODE *bst, datatype k)//删除某一个节点
{
    BSTNODE *p,*f,*q,*s;
    p = bst;
    f = nullptr;
    while (p){
        if (p->key == k)break;
        f = p;
        if (p->key < k)p = p->rightchild;
        else p = p->leftchild;
    }

                    
    if (p == nullptr){
        return bst;
    }

    if (p->leftchild == nullptr){
        if (f == nullptr){
            bst = p->rightchild;
        }
        else if (f->leftchild == p)f->leftchild = p->rightchild;
        else f->rightchild = p->rightchild;

        free(p);
    }
    else{
        q = p;
        s = p->leftchild;
        while (s->rightchild){
            q = s;
            s = s->rightchild;
        }
        if (q == p){
            q->leftchild = s->leftchild;
        }
        else{
            q->rightchild = s->leftchild;
        }
        p->key = s->key;
        free(s);
    }
    return bst;
}

void visit(BSTtree root){
    cout << root->key << " ";
}

void preprint(BSTtree root){
    if (root){
        visit(root);
        preprint(root->leftchild);
        preprint(root->rightchild);
    }
}

void inprint(BSTtree root){
    if (root){

        inprint(root->leftchild);
        visit(root);
        inprint(root->rightchild);
    }
}

void postprint(BSTtree root){
    if (root){
        
        postprint(root->leftchild);
        postprint(root->rightchild);
        visit(root);
    }
}



#endif

1、二叉排序树：是一种高效的数据结构。

性质：（1）若果他的左子树不为空，则左子树上的所有节点的值都小于根节点的值。

（2）若他的右子树不为空，则右子树上的所有节点的值都大于根节点的值。

（3）他的左右子树也分别是二叉排序树。

注意：（1）对一颗二叉排序树进行中序遍历，可以得到一个递增的有序序列。这也是二叉排序树的原由。

（2）由于二叉树可以看成一个有序表，所以在二叉排序树上进行的查找类似于折半查，就是逐步缩小查找范围的过程。

1、若给定值等于根节点的关键字，则查找成功。

2、若给定值小于根节点的关键字，则继续在左子树上进行查找。

3、若给定值大于根节点的关键字，则继续在右子树上进行查找。

bsttree search(bsttree bst,datatype){

bsttree q;
q = bst;
while(q){
if(q->key == k)return q;
if(q->key>k)q=q->leftchild;
else{q = q->rightchild;}
}  
return NULL;
}

2、二叉排序树的插入：

首先查找待插入的记录是否在树中，如果存在则不允许插入重复关键字。如果找到叶子节点人没有发现关键字，则把待插入节点作为新的叶子节点插入。

void insertbst(bstree *bst,datatype k){
bitree s;
if(*bst == NULL)
{
s = (bsttree)malloc(sizeof(bstnode));
s->key = k;
s->leftchild = NULL;
s->rightchild = NULL;
*bst = s;
}
else if(k<(*bst)->key)insert(&(*bst)->leftchild,k);
eles if(k>(*bst)->key)insert(&(*bst)->rightchild,k);
}

3、二叉排序树的建立：

二叉排序树的建立是基于插入算法进行的，根据给定的关键字的顺序依次插入得到的。

void createbst(bstree *bst)
{
datatype key;
*bst = NULL;
cout<<"输入二叉树元素"<<endl;
for(int i = 0;i<N;i++)
{
cin>>key;
instrtbst(bst,Key);
}
}

void createbst(bstree *bst)
{
datatype key;
*bst = NULL;
cout<<"输入二叉树元素"<<endl;
for(int i = 0;i<N;i++)
{
cin>>key;
instrtbst(bst,Key);
}
}

4、二叉排序树的删除：

二叉排序树要求关键字之间满足某种大小关系，这就使得从树中删除一个节点的算法相对复杂。首先在二叉排序树中查找待删除的节点，不存在不做操作，否则分三种情况讨论：

（1）待删除节点是叶子节点（2）待删除节点之后右/左子树（3）待删除节点有左右子树

看第三种情况：只需要将带删除节点的父亲节点的相应孩子域之为该孩子对应的左子树或右子树。

bstnode * del(bsttree bst,datatype k)
{
bstnode*p,*f,*s,*q;
p = bst;
f= NULL;
while(p){
if(p->key == k) break;
f = p;
if(p->key>k) p = p->lchild;
else p = p->rchild;
}
if(p == NULL) return bst;
if(p->lchild == NULL){
if(f == NULL){ bst = p->rchild;}
else if(f->lchild == p){f->lchild = p->rightchild;}
else {f->rchild = p->rchild;}
free(p);
}
eles{
q = p;
s = p->lchild;
while(s->rchild){
q = s;
s = s->rchild;
}
if(q == p)
{
q->lchild = s->lchild;
}
else{
q->rchild = s->lchild;
p->key = s->key;
free(s);
}
}
return bst;
}

5、二叉排序树的性能分析：

二叉排序树的最慢查找速度相当于顺序查找。

但是对于二叉排序树的删除和吵着来说，只需要修改某些节点的指针域，不需要大量的移动其他的记录，动态查找的效率更高！