二叉搜索树

原创 2017年08月30日 19:14:38

关于二叉树的基本操作请转到我的另一篇博客:
http://blog.csdn.net/qq_30091945/article/details/77531651

概念

Binary Search Tree,也可称为二叉搜索树,二叉排序树。
它或者是一棵空树,或者是具有下列性质的二叉树:
若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值; 它的左、右子树也分别为二叉排序树。


查找操作

算法如下:
1)树为空,返回NULL
2)树非空时,对根节点的键值与x即你想那个比较,如果相等则返回根节点
3)如果x小于根结点的键值,在左子树进行查找x
4)如果x大于根结点的键值,在右子树进行查找x
代码如下:

//按值查找结点
BinarySearchTree* Find(BinarySearchTree* BST,int data){
    BinarySearchTree* cur = BST;
    //搜索树为空,返回NULL 
    if(cur == NULL){
        return NULL; 
    }
    while(cur){
        //根节点值与data相等,返回根节点 
        if(cur->data == data){
            return cur;
        }else if(cur->data < data){
            //比data小,则在左子树里寻找 
            cur = cur->lchild;
        }else{//否则在右子树里寻找 
            cur = cur->rchild;
        }
    }
}

查找最大最小值

根据二叉搜索树的定义可以知道,最大值一定在最右分支的端节点上,最小值在最左分支的端节点上。
查找最小值算法如下:

//查找最小值
BinarySearchTree* FindMin(BinarySearchTree* BST){
    BinarySearchTree* cur = BST;
    //搜索树为空时,返回NULL 
    if(cur == NULL){
        return NULL;
    } 
    while(cur){
        //左子树为空时,返回该节点 
        if(cur->lchild == NULL){
            return cur;
        }else{//否则在左子树里找最小值 
            cur = cur->lchild;
        }
    }
}

查找最大值算法如下:

//查找最大值
BinarySearchTree* FindMax(BinarySearchTree* BST){
    BinarySearchTree* cur = BST;
    //搜索树为空时,返回NULL 
    if(cur == NULL){
        return NULL;
    } 
    while(cur){
        //右子树为空时,返回该节点 
        if(cur->rchild == NULL){
            return cur;
        }else{//否则在右子树里找最小值 
            cur = cur->rchild;
        }
    }
}

插入操作

算法如下:
1)树空时,直接构造一个根节点即可。
2)树非空时,x小于根节点键值时,那么递归插入到左子树上。
3)x大于根节点键值时,那么队规插入到右子树上。
算法如下:

//插入函数
BinarySearchTree* Insert(BinarySearchTree* BST,int data){
    //搜索树为空,则构建根节点 
    if(!BST){
        BST = new BinarySearchTree;
        BST->data = data;
        BST->lchild = BST->rchild = NULL; 
    }else{
        //若data小于根节点的值,则插入到左子树 
        if(data < BST->data){
            BST->lchild = BST->Insert(BST->lchild,data);
        }else if(data > BST->data){
            //若data小于根节点的值,则插入到左子树
            BST->rchild = BST->Insert(BST->rchild,data);
        }
    }
    return BST;
}

删除操作

算法如下:
1)树空时,直接返回NULL
2)树非空时,如果要删除的是叶子节点时,直接删除,并把父节点的相应指针置为NULL。
3)要删除的只有一个孩子时,把其父节点的指针指向要删除的结点的孩子结点。
4)要删除的有两个孩子结点时,用另一个结点代替被删除的结点:右子树的最小结点或者左子树的最大结点
下面是3种情况图示:
这里写图片描述
这里写图片描述
这里写图片描述
算法如下:

//删除操作 
BinarySearchTree* Delete(BinarySearchTree* BST,int data){
    if(!BST){//树空时,直接返回NULL 
        return BST;
    }else if(data < BST->data){
        //data小于根节点时,到左子树去删除data 
        BST->lchild = this->Delete(BST->lchild,data);
    }else if(data > BST->data){
        //data大于根节点时,到右子树去删除data 
        BST->rchild = this->Delete(BST->rchild,data); 
    }else{//data等于根节点时 
        if(BST->lchild && BST->rchild){
            //左右子树都不空时,用右子树的最小来代替根节点
            BinarySearchTree* tmp = this->FindMin(BST->rchild);
            BST->data = tmp->data;
            //删除右子树的最小结点 
            this->Delete(BST->rchild,tmp->data);
        }else{//当左右子树都为空或者有一个空时 
            BinarySearchTree* tmp = BST;
            if(!BST->lchild){//左子树为空时 
                BST = BST->rchild;
            }else if(!BST->rchild){//右子树为空时 
                BST = BST->lchild; 
            }
            delete tmp; 
        }
    }
    return BST;
}

下面是基于下图所示二叉搜索树的具体实例程序结果:

这里写图片描述
全部代码如下:

#include <iostream>
using namespace std;

class BinarySearchTree{
    private:
        int data;
        BinarySearchTree* lchild;
        BinarySearchTree* rchild;
    public:
        //查找最小值
        BinarySearchTree* FindMin(BinarySearchTree* BST){
            BinarySearchTree* cur = BST;
            //搜索树为空时,返回NULL 
            if(cur == NULL){
                return NULL;
            } 
            while(cur){
                //左子树为空时,返回该节点 
                if(cur->lchild == NULL){
                    return cur;
                }else{//否则在左子树里找最小值 
                    cur = cur->lchild;
                }
            }
        }

        //查找最大值
        BinarySearchTree* FindMax(BinarySearchTree* BST){ 
            BinarySearchTree* cur = BST;
            //搜索树为空时,返回NULL
            if(cur == NULL){
                return NULL;
            } 
            while(cur){
                //右子树为空时,返回该节点 
                if(cur->rchild == NULL){
                    return cur; 
                }else{//否则在左子树里找最小值 
                    cur = cur->rchild;
                }
            }
        }

        //按值查找结点
        BinarySearchTree* Find(BinarySearchTree* BST,int data){
            BinarySearchTree* cur = BST;
            //搜索树为空,返回NULL 
            if(cur == NULL){
                return NULL; 
            }
            while(cur){
                //根节点值与data相等,返回根节点 
                if(cur->data == data){
                    return cur;
                }else if(cur->data < data){
                    //比data小,则在左子树里寻找 
                    cur = cur->lchild;
                }else{//否则在右子树里寻找 
                    cur = cur->rchild;
                }
            }
        }

        //插入函数
        BinarySearchTree* Insert(BinarySearchTree* BST,int data){
            //搜索树为空,则构建根节点 
            if(!BST){
                BST = new BinarySearchTree;
                BST->data = data;
                BST->lchild = BST->rchild = NULL; 
            }else{
                //若data小于根节点的值,则插入到左子树 
                if(data < BST->data){
                    BST->lchild = BST->Insert(BST->lchild,data);
                }else if(data > BST->data){
                    //若data小于根节点的值,则插入到左子树
                    BST->rchild = BST->Insert(BST->rchild,data);
                }
            }
            return BST;
        }

        //二叉搜索树的构造,利用data数组构造二叉搜索树 
        BinarySearchTree* Create(int* data,int size){
            BinarySearchTree* bst = NULL; 
            for(int i = 0 ; i < size ; i++){
                bst = this->Insert(bst,data[i]);
            }
            return bst;
        }

        //递归前序遍历 
        void PreorderTraversal(BinarySearchTree* T){
            if(T == NULL){
                return;
            }
            cout<<T->data<<" ";                         //访问根节点并输出 
            T->PreorderTraversal(T->lchild);            //递归前序遍历左子树 
            T->PreorderTraversal(T->rchild);            //递归前序遍历右子树
        }

        //递归中序遍历 
        void InorderTraversal(BinarySearchTree* T){
            if(T == NULL){
                return;
            }
            T->InorderTraversal(T->lchild);             //递归中序遍历左子树 
            cout<<T->data<<" ";                         //访问根节点并输出 
            T->InorderTraversal(T->rchild);             //递归中序遍历左子树 
        }

        //递归后序遍历 
        void PostorderTraversal(BinarySearchTree* T){
            if(T == NULL){
                return;
            }
            T->PostorderTraversal(T->lchild);           //递归后序遍历左子树 
            T->PostorderTraversal(T->rchild);           //递归后序遍历右子树 
            cout<<T->data<<" ";                         //访问并打印根节点 
        }

        //删除操作 
        BinarySearchTree* Delete(BinarySearchTree* BST,int data){
            if(!BST){//树空时,直接返回NULL 
                return BST;
            }else if(data < BST->data){
                //data小于根节点时,到左子树去删除data 
                BST->lchild = this->Delete(BST->lchild,data);
            }else if(data > BST->data){
                //data大于根节点时,到右子树去删除data 
                BST->rchild = this->Delete(BST->rchild,data); 
            }else{//data等于根节点时 
                if(BST->lchild && BST->rchild){
                    //左右子树都不空时,用右子树的最小来代替根节点
                    BinarySearchTree* tmp = this->FindMin(BST->rchild);
                    BST->data = tmp->data;
                    //删除右子树的最小结点 
                    BST->rchild = this->Delete(BST->rchild,tmp->data);
                }else{//当左右子树都为空或者有一个空时 
                    BinarySearchTree* tmp = BST;
                    if(!BST->lchild){//左子树为空时 
                        BST = BST->rchild;
                    }else if(!BST->rchild){//右子树为空时 
                        BST = BST->lchild; 
                    }
                    delete tmp; 
                }
            }
            return BST;
        }

        int getdata(BinarySearchTree* BST){
            return BST->data;
        }
};

int main()
{
    int size;
    cout<<"请输入结点个数:"<<endl; 
    cin>>size;
    int* data;
    data = new int[size];
    cout<<"请输入每个结点的值:"<<endl;
    for(int i = 0 ; i < size ; i++){
        cin>>data[i];
    }
    BinarySearchTree* bst;
    bst = new BinarySearchTree;
    bst = bst->Create(data,size);

    cout<<"前序遍历(递归):"<<endl;
    bst->PreorderTraversal(bst);
    cout<<endl;

    cout<<"中序遍历(递归):"<<endl;
    bst->InorderTraversal(bst);
    cout<<endl;

    cout<<"后序遍历(递归):"<<endl;
    bst->PostorderTraversal(bst);
    cout<<endl;

    BinarySearchTree* bst_max;
    bst_max = bst->FindMax(bst);
    cout<<"二叉搜索树的最大值为:"<<endl;
    cout<<bst_max->getdata(bst_max);
    cout<<endl;

    cout<<"二叉搜索树的最小值为:"<<endl;
    BinarySearchTree* bst_min; 
    bst_min = bst->FindMin(bst);
    cout<<bst_min->getdata(bst_min);     
    cout<<endl;

    int num;
    cout<<"请输入要删除的结点:"<<endl;
    cin>>num;
    bst = bst->Delete(bst,num);
    cout<<"删除之后:"<<endl;
    cout<<"前序遍历(递归):"<<endl;
    bst->PreorderTraversal(bst);
    cout<<endl;

    cout<<"中序遍历(递归):"<<endl;
    bst->InorderTraversal(bst);
    cout<<endl;

    cout<<"后序遍历(递归):"<<endl;
    bst->PostorderTraversal(bst);
    cout<<endl;

    cout<<"请输入要删除的结点:"<<endl;
    cin>>num;
    bst = bst->Delete(bst,num);
    cout<<"删除之后:"<<endl;
    cout<<"前序遍历(递归):"<<endl;
    bst->PreorderTraversal(bst);
    cout<<endl;

    cout<<"中序遍历(递归):"<<endl;
    bst->InorderTraversal(bst);
    cout<<endl;

    cout<<"后序遍历(递归):"<<endl;
    bst->PostorderTraversal(bst);
    cout<<endl;

    cout<<"请输入要删除的结点:"<<endl;
    cin>>num;
    bst = bst->Delete(bst,num);
    cout<<"删除之后:"<<endl;
    cout<<"前序遍历(递归):"<<endl;
    bst->PreorderTraversal(bst);
    cout<<endl;

    cout<<"中序遍历(递归):"<<endl;
    bst->InorderTraversal(bst);
    cout<<endl;

    cout<<"后序遍历(递归):"<<endl;
    bst->PostorderTraversal(bst);
    cout<<endl;

    return 0;
 } 

截图如下:
这里写图片描述

版权声明:本文为博主原创文章,未经博主允许不得转载。若需转载,请注明http://blog.csdn.net/qq_30091945 举报

相关文章推荐

概念堆是一个用数组表示的完全二叉树,并满足以下两个特性: 1)父节点的键值总是大于或等于(小于等于)其子树上的任意结点 2)每个结点的左子树和右子树都是个堆。 如果父节点的键值总是大于等于任何一...

local function definitions are illegal解决办法

原文出处http://wenku.baidu.com/view/1f3eb740c850ad02de8041ac.html 编译错误:local function definitions are i...

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

数组实现根据二叉树的先序遍历和中序遍历构造二叉树

根据二叉树的先序遍历和中序遍历构造二叉树是非常经典的一道算法题目,但是在网上找到的资料绝大多数都是使用链接方式构造二叉树,感觉这样比较繁琐,因此自己写了一个数组实现的程序,当然,程序不算很完善,还望朋...

平衡二叉树

由于平衡二叉树的前提是二叉搜索树,故关于二叉搜索树的内容请移步如下网址:http://blog.csdn.net/qq_30091945/article/details/77720865概念平衡因子:...

2014年计算机联考真题——带权路径长度之和

思路如下: 利用层次遍历的思路,记录每层的层数level,对于该层的每个叶节点的带权路径长度 = data*(level-1) 算法如下: //求叶子节点带权路径长度之和 ...

根据二叉树的前序遍历和中序遍历,重构出二叉树

题目:这道题目是一道面试题,先序遍历和中序遍历以数组的形式给出,要求我们根据这两个条件重构出二叉树。 下图是一棵二叉树 // 6 // / \...

并查集

并查集并查集是一种树形结构,又叫“不相交集合”,保持了一组不相交的动态集合,每个集合通过一个代表来识别,代表即集合中的某个成员,通常选择根做这个代表。初始化用数组来建立一个并查集,数组下标代表元素,下...

二叉树的构建及其遍历算法

概要二叉树是一种非常重要的数据结构,很多其他数据机构都是基于二叉树的基础演变过来的。二叉树有先、中、后,层次四种遍历方式,因为树的本身就是用递归定义的,因此采用递归的方法实现三种遍历,不仅代码简洁且容...

根据先序序列与中序序列构建二叉树

算法如下: 1)先在先序序列中找到根结点, 2)在中序序列中找到根结点位置,(可以将二叉树分为左子树和右子树) 3)用同样的办法构造左子树 4)用同样的办法构造右子树。//根据先序序列与中序序...

从大到小输出二叉搜索树中键值不小于K的关键字

概要这是王道数据结构复习资料上的一道题。该书给出了递归算法,但是解析中对于非递归算法说使用非递归中序遍历的思路进行解答,这明显有错误。根据 二叉搜索树的性质可知,二叉搜索树的中序遍历是从小到大的序列,...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)