二叉排序树（二叉查找树）

最新推荐文章于 2021-09-09 22:21:01 发布
最新推荐文章于 2021-09-09 22:21:01 发布
阅读量969 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyl424525/article/details/72816504
版权

1.相关概念
节点的度：一个节点拥有子树的数目。
树的高度：也称为树的深度，树中节点的最大层次。
二叉树或者为空集，或者由一个根节点和两棵互不相交的、分别称为左子树和右子树的二叉树组成。从定义可以看出一棵二叉树：
二叉树是有序树，区分左子树与右子树，不可以随意交换子树位置。
二叉树共有5种形态
所有节点都只有左子树的二叉树叫做左斜树，所有节点都只有右子树的二叉树叫做右斜树。左斜树和右子树统称为斜树。
斜树已经退化成线性结构，二叉树在查找上表现出来优异性能在斜树得不到体现。

完全二叉树
在一棵二叉树中，只有最下两层的度可以小于2，并且最下一层的叶子节点集中出现在靠左的若干位置上。
或者这样定义：对一棵具有n个节点的二叉树按层序从左到右编序，二叉树树某个节点的编序与同样位置的满二叉树节点的编序相同如果所有节点都满足这个条件，则二叉树为完全二叉树。

满二叉树
满二叉树要满足两个条件：
所有的节点都同时具有左子树和右子树。
所有的叶子节点都在同一层上。
在同样深度的二叉树中，满二叉树的节点数目是最多的，叶子数也是最多的。

二叉查找树
二叉查找树也称为二叉搜索树或二叉排序树。二叉排序树的节点包含键值key。二叉排序树或者是一棵空树，否则要求：
若它的左子树不为空，那么左子树上所有节点的key都小于根节点的key
若它的右子树不为空，那么右子树上所有节点的key都大于根节点的key
它的左右子树也分别为二叉排序树

根据定义，二叉查找树中没有重复key的节点。

二叉树的性质
性质一：在二叉树的第i层上至多有2^(i-1)个节点(i>=1)
性质二：深度为k的二叉树至多有2^k-1个节点
性质三：对任何一棵二叉树T，如果终端节点数为n0，度为2的节点数为n2 ，那么 n0 = n2 +1
证明：二叉树节点度数最大为2，则 ： n = n0 + n1 + n2 (等式一)
从孩子个数角度出发： 度为0的节点没有孩子， 度为1的节点没有1个孩子，度为2的节点有2个孩子，孩子总数为 n00 + n11 +n2 2 = n1+2n2；
树的所有节点中，只有根不是任何节点的孩 子，因此有 n -1 = n1 + 2* n2 ,即 n = n1 + 2* n2 + 1. （等式二）
由等式一等式而可以推出 n0 = n2 +1

性质四： 具有n个节点的完全二叉树的高度为至少为log2(n+1)
证明：高度为h的二叉树最多有2{h}–1个结点。反之，对于包含n个节点的二叉树的高度至少为log2(n+1)。

性质五：如果对一棵有n个节点的完全二叉树的节点按层序编号（从第一层开始到最下一层，每一层从左到右编号），
对任一节点i有：
如果i=1 ，则节点为根节点，没有双亲。
如果2 * i > n ，则节点i没有左孩子 ；否则其左孩子节点为2*i . （n为节点总数）
如果2 * i+1>n ，则节点i没有右孩子；否则其右孩子节点为2*1+1

2.代码实现
BSNode.h


#ifndef DATASTRUCTURE_BSNODE_H
#define DATASTRUCTURE_BSNODE_H

//二叉查找树的节点结构
template <typename T>
class BSNode {
public:
    BSNode(T t): value(t), lchild(nullptr), rchild(nullptr){}


    BSNode() = default;

    T value;

    BSNode<T>* lchild;
    BSNode<T>* rchild;
    BSNode<T>* parent;
};

//        value:节点的值，也即是上文的key，类型由模板参数决定
//        lchild :指向节点的左孩子
//        rchild:指向节点的右孩子
//        parent: 指向节点的双亲
#endif //DATASTRUCTURE_BSNODE_H

BSTree.h

#ifndef DATASTRUCTURE_BSTREE_H
#define DATASTRUCTURE_BSTREE_H

#include <iostream>
#include "BSNode.h"
using namespace std;

//这里我们定义了二叉排序树的类型BSTree。它包含了：
//
//BSTree的根节点root，这是唯一的数据成员
//        操作的外部接口与内部实现接口。
//例如 preOrder()为提供给用户使用的接口，接口声明为public；
//而preOrder(AVLTreeNode* pnode)是类内部为了递归操作所使用的接口，接口声明为private。
//提供的其他接口都有相应的备注说明。

//二叉查找树
template <typename  T>
class BSTree {
public:
    BSTree();
    ~BSTree();

    void preOrder();                 //前序遍历
    void inOrder();                //中序遍历
    void postOrder();            //后序遍历
    void layerOrder();          //层次遍历

    BSNode<T>* search_recursion(T key);//递归地进行查找
    BSNode<T>* search_Iterator(T key);        //迭代地进行查找

    T search_minimum();//查找最小元素
    T search_maximum();查找最大元素

    BSNode<T> * successor (BSNode<T> * x);     //查找指定节点的后继节点
    BSNode<T> * predecessor(BSNode<T> * x);    //查找指定节点的前驱节点

    void insert(T key);    //插入指定值节点
    void remove(T key);    //删除指定值节点
    void destory();        //销毁二叉树
    void print();        //打印二叉树


    BSNode <T> * root;//根节点
    BSNode<T>* search(BSNode<T>* & p, T key);
    void remove(BSNode<T>*  p, T key);
    void preOrder(BSNode<T>* p);
    void inOrder(BSNode<T>* p);
    void postOrder(BSNode<T>* p);
    T search_minimun(BSNode<T>* p);
    T search_maximum(BSNode<T>* p);

    void destory(BSNode<T>* &p);


};

/*默认构造函数*/
template <typename T>
BSTree<T>::BSTree() :root(nullptr){}

template <class T>
BSTree<T>::~BSTree() {
    destory(root);
}

template <class  T>
void BSTree<T>::insert(T key) {
    BSNode<T> * pparent= nullptr;//记录合适的插入位置
    BSNode<T> * pnode=root;寻找合适的插入位置

    while (pnode!=nullptr){//寻找
        //nullptr是c++中空指针类型的关键字。
        pparent=pnode;
        if(key> pnode->value){
            pnode=pnode->rchild;
        }else if(key<pnode->value){
            pnode=pnode->rchild;
        } else
            break;
    }

    pnode=new BSNode<T> (key);//以元素的值构建新节点


    //插入
    if(pparent== nullptr){ //如果是空树
        root=pnode;  //则新节点为根
    } else{
        if(key >pparent->value){
            pparent->rchild=pnode;//否则新节点为其父节点的左孩
        } else
            pparent->lchild=pnode;//或右孩
    }

    pnode->parent=pparent; //指明新节点的父节点
}




//前序遍历
//若二叉树为空，则空操作返回，否则先访问根节点，然后前序遍历左子树，再前序遍历右子树。（简记为：VLR）


//preOrder(AVLTreeNode* pnode)是类内部为了递归操作所使用的接口，接口声明为private。
template <typename  T>
void BSTree<T>::preOrder() {
    preOrder(root);
}

template <class  T>
void BSTree<T>::preOrder(BSNode<T> *p) {
    if(p!= nullptr)//不为空节点
    {
        cout<<p->value<<endl;
        preOrder(p->lchild);
        preOrder(p->rchild);
    }
}


//rchild中序遍历
//若二叉树为空，则空操作返回，否则从根节点开始，中序遍历根节点的左子树，然后访问根节点，最后中序遍历右子树。（简记为：LVR）
template<typename  T>
void BSTree<T>::inOrder() {
    inOrder(root);
}

template <class T>
void BSTree<T>::inOrder(BSNode<T> *p) {
    if(p!= nullptr){

        inOrder(p->lchild);
        cout<<p->value<<endl;
        inOrder(p->rchild);
    }
}

//
//后序遍历
//若树为空，则返回空操作，否则从左到右先叶子后节点的方式遍历访问左右子树，左右子树都访问结束，才访问根节点。（简称LRV）
template <class T>
void BSTree<T>::postOrder() {
    postOrder(root);
}

template<class T>
void BSTree<T>::postOrder(BSNode<T> *p) {
    if(p!= nullptr){
        postOrder(p->lchild);
        postOrder(p->rchild);
        cout<<p->value<<endl;
    }
}

//对于一棵二叉排序树，中序遍历时刚好可以输出一个非递减的序列。
//一个节点的前驱节点有3种情况：
//它有左子树，则其前驱节点为其右子树的最右节点
//它没有左子树，且它本身为右子树，则其父节点为其前驱节点
//它没有左子树，且它本身为左子树，则它的前驱节点为“拥有右子树的最近父节点”

/*寻找其前驱节点*/
template <class T>
BSNode<T> * BSTree<T>::predecessor(BSNode<T> *pnode) {
    if(pnode->lchild!= nullptr)//它有左子树
    {
        pnode=pnode->lchild;
        while(pnode->rchild!= nullptr){
            pnode=pnode->rchild;
        }
        return pnode;
    }
    //以下均为无左子树
    BSNode<T>* pparent=pnode->parent;
    while(pparent!= nullptr&&pparent->lchild==pnode){
        //如果进入循环，则是第三种情况:它本身为左子树，
        // 否则为第二种情况
        //拥有右子树的最近父节点
        pnode=pparent;
        pparent=pparent->parent;
    }
//、、、、、、、、、、、、、、、、、、、、、、、
    return pparent;
}
//一个节点的后继节点也有三种情况：
//它有右子树；则其后继节点为其右子树的最左节点
//同样的，
// 它没有右子树，但它本身是一个左孩子，则后继节点为它的双亲
//它没有右子树，但它本身是一个右孩子，则其后继节点为“具有左孩子的最近父节点”

//寻找其后继节点
template <class  T>
BSNode<T> * BSTree<T>::successor(BSNode<T> *x) {
    if(x->rchild!= nullptr){//右右子树
        x=x->rchild;
        while(x!= nullptr)
            x=x->lchild;
        return x;
    }
    //没有右子树
    BSNode<T> * xparent=x->parent;
    while(xparent!= nullptr&&xparent->rchild==x)
    {
//具有左孩子的最近父节点
        x=xparent;
        xparent=xparent->parent;

//        if(xparent->lchild!= nullptr)
//            return xparent;
    }
    return xparent;
}

/*删除二叉排序树的某个节点有三种情况：
被删除节点同时有左子树与右子树。
被删除节点只有左子树或只有右子树。
被删除节点没有子树。

对于第一种情况，我们的处理方式是将前驱节点的值保存在当前结点，继而删除前驱节点。
对于第二种情况，我们直接用子树替换被删节点。
对于第三种情况，我们可以直接删除节点。
 */

/*删除指定节点*/
template <class  T>
void BSTree<T>::remove(T key) {
    remove(root,key);
}
/*删除指定节点*/
/*内部使用函数*/
template <class T>
void BSTree<T>::remove(BSNode<T> *p, T key) {
    if(p!= nullptr){
        if(p->value==key){
            BSNode<T> * pdel= nullptr;//记录要删除的节点
            if(p->lchild== nullptr||p->rchild== nullptr)
                //情况二、三：被删节点只有左子树或右子树，或没有孩子
                pdel=p;
            else
                pdel=predecessor(p); //情况一：被删节点同时有左右子树，将前驱节点的值保存在当前结点，继而删除前驱节点。

            //此时，被删节点只有一个孩子(或没有孩子),保存该孩子指针
            BSNode<T> *pchild= nullptr;
            if(pdel->lchild!= nullptr)
                pchild=pdel->lchild;
            else
                pchild=pdel->rchild;

            //让孩子指向被删节点的父节点
            if(pchild!= nullptr)
                pchild->parent=pdel->parent;


            //让被删节点的父节点指向被删节点的孩子节点
            //如果要删除的节点是头结点，注意更改4root值
            if(pdel->parent== nullptr)
                root=pchild;
                //如果要删除的节点不是头节点，要注意更改它的双亲节点指向新的孩子节点
            else if(pdel->parent->lchild==p)
                pdel->parent->lchild=pchild;
            else
                pdel->parent->rchild=pchild;


            if(p->value!=pdel->value)
                p->value=pdel->value;
            delete pdel;
        }
            //进行递归删除
        else if(key>p->value)
            remove(p->rchild,key);
        else
            remove(p->lchild,key);
    }
}

/*查找指定元素的节点（非递归）*/
template <class T>
BSNode<T>* BSTree<T>::search_Iterator(T key) {
    BSNode<T> * pnode=root;
    while(pnode!= nullptr){
        if(key==pnode->value)//找到
            return pnode;
        if(key>pnode->value)
            pnode=pnode->rchild; //关键字比节点值大，在节点右子树查找
        else
            pnode=pnode->lchild;//关键字比节点值小，在节点左子树查找
    }
    return pnode;
}
/*查找指定元素的节点（递归）*/
template <class T>
BSNode<T> * BSTree<T>::search_recursion(T key) {
    return search(root,key);
}

/*private:search()*/
/*递归查找的类内部实现*/
template <typename T>
BSNode<T>* BSTree<T>::search(BSNode<T> *&p, T key) {
    if(p== nullptr)
        return nullptr;
    if(p->value==key)
        return p;
    if(key>p->value)
        return search(p->rchild,key);
    return search(p->lchild,key);
}

/*寻找最小元素*/
template <typename T>
T BSTree<T>::search_minimum() {
    return search_minimun(root);
}
template<class T>
T BSTree<T>::search_minimun(BSNode<T> *p) {
    if(p->lchild!= nullptr)
        return search_minimun(p->lchild);
    return p->value;
}

/*寻找最大元素*/
template <typename T>
T BSTree<T>::search_maximum()
{
    return search_maximum(root);
}
template<class T>
T BSTree<T>::search_maximum(BSNode<T> *p) {
    if(p->rchild!= nullptr)
        return search_maximum(p->rchild);
    return p->value;
}

/*销毁二叉树*/
//使用后序遍历递归销毁二叉树
template<class T>
void BSTree<T>::destory() {
    destory(root);
}

template <class T>
void BSTree<T>::destory(BSNode<T> *&p) {
    if(p!= nullptr){
        if(p->lchild!= nullptr)
            destory( p->lchild);
        if(p->rchild!= nullptr)
            destory(p->rchild);
        delete p;
        p=nullptr;
    }
}

#endif //DATASTRUCTURE_BSTREE_H

测试：main.cpp

#include <iostream>
#include "BSTree/BSTree.h"

using namespace std;
int main() {
    BSTree <int> t;
    t.insert(62);
    t.insert(58);
    t.insert(47);
    t.insert(51);
    t.insert(35);
    t.insert(37);
    t.insert(88);
    t.insert(73);
    t.insert(99);
    t.insert(93);
    t.insert(95);

    cout<<"中序遍历:"<<endl;
    t.inOrder();

    cout<<"最大元素:"<<t.search_maximum()<<endl;
    cout<<"最小元素:"<<t.search_minimum()<<endl;

    cout<<"删除元素99"<<endl;
    t.remove(99);
    cout << "最大元素:" << t.search_maximum() << endl;
    t.insert(111);
    cout<<"插入111"<<endl;
    cout << "最大元素:" << t.search_maximum() << endl;
    t.destory();

    return 0;
}

输出：
中序遍历:
37
62
73
88
95
99
最大元素:99
最小元素:37
删除元素99
最大元素:95
插入111
最大元素:111

不务正业的土豆
关注
专栏目录
二叉排序树或二叉搜索树
zhaohong_bo的专栏
05-19 1872
一、二叉树基础 1.1 二叉排序树定义 二叉排序树（Binary Sort Tree）又称二叉查找(搜索)树（Binary Search Tree）。它是一颗空树，或者具有下列性质： 若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树分别为二叉排序树。 上述性质简称二叉排序树性质(BST性质)，故二...
二叉搜索树(二叉查找树、二叉排序树)及其实现
luoluozlb
08-17 1250
二叉排序树的定义二叉排序树（Binary Sort Tree），又称二叉查找树、二叉搜索树。它或者是一棵空树；或者是具有下列性质的二叉树： 1. 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2. 若右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3. 左、右子树也分别为二叉排序树。存储结构： typedef struct bst_node { int
数据结构树--＞二叉查找树\二叉排序树
路漫漫其修远兮
08-12 2180
二叉查找树\二叉排序树 二叉查找树是一种有序的二叉树，也叫儿叉排序树，它在二叉树的基础上添加了位置排序的规则。 规则： 每颗子树的根节点值比左子树大，比右子树小。 二叉查找树的缺点： 二叉查找树有了排序，但当我们的数据顺序与大小规律一致是就会发现，二叉查找树基本退化为了链表，导致达不到二叉 查找树快速查找的目的。 后续我们在介绍平衡二叉树的时候会解决之一问题。 1. 二叉查找树的查找 更具儿叉查找树的特性二叉查找树查找元素快速简单，快速：二叉查找树查找基本就是二分查找，所以快速。 2. 二叉查找树的插入
二叉查找树（二叉排序树）
ACM,再见！
12-17 958
二叉排序树的建立，查找，删除节点的操作。 #include #include #include #include using namespace std; struct node { int key;///结点值 node *left; node *right; node *parent;///指向父亲结点的指针 }; ///递归中序遍历排序二叉树 vo
二叉搜索树(二叉排序树)
热门推荐
爱敲代码的三毛的博客
09-09 4万+
一.概念 二叉搜索树又称二叉排序树，具有以下性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注意：二叉搜索树中序遍历的结果是有序的 二、基本操作 1.查找元素 思路：二叉搜索树的左子树永远是比根节点小的，而它的右子树则都是比根节点大的值。当前节点比要找的大就往左走，当前元素比要找的小就往右走 public Node search(int key) { if(root ==
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
动态查找利用二叉排序树完成动态查找表
03-04
利用二叉排序树完成动态查找表的建立、指定关键字的查找、插入与删除指定关键字结点。 算法输入：指定一组数据。 算法输出：显示二叉排序树的中序遍历结果、查找成功与否的信息、插入和删除后的中序遍历结果(排序...
二叉排序树的建立、插入、查找和删除
08-04
代码里有二叉排序树插入操作递归算法，二叉排序树插入操作非递归算法，二叉排序树删除操作，创建二叉排序树，二叉排序树查找递归算法，二叉排序树查找非递归算法
二叉搜索树（二叉排序树）
skyinmoon的专栏
07-01 618
内容和代码参考殷人昆版的《数据结构》 二叉搜索树也称为二叉排序树，二叉搜索树要么是空树，要么具有如下性质： （1）每个结点都有一个作为搜索依据的结点值，并且每个结点值互不相同； （2）左子树（如果存在）上的所有结点值都小于根结点的值； （3）右子树（如果存在）上的所有结点值都大于根结点的值； （4）左子树和右子树也是二叉搜索树。 对一棵二叉搜索树进行中序遍历，可以从小到大的将结
二叉树_二叉搜索树_二叉排序树
ShirleyPaul_SmallWorld
05-29 244
二叉排序树又称为二叉查找树，二叉搜索树。二叉排序树和普通的二叉树在结构上一样，它要么是一棵空树，要么是这样的一棵二叉树：对任意结点，如果左子树不为空，则左子树上所有结点的权值都小于该结点的权值；如果右子树不为空，则右子树上所有结点的权值都大于该结点的权值；任意结点的左子树和右子树都是一棵二叉排序树；一般而言， 二叉排序树上结点的权值都是唯一的。在二叉排序树上，对于任意结点，如果有左子树和右子树，那么
二叉查找树，二叉搜索树，二叉排序树
chushouxiu0552的博客
03-13 98
二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均...
数据结构之 二叉搜索树、二叉排序树、BST树
cyt
02-06 294
二叉搜索树 BST 二叉搜索树简称BST树 二叉搜素树是二叉树的一种，数组这种数据结构也能够实现对元素的快速查找，但是对于元素的添加、删除和更新操作，使用数组来实现的话，就会存在较高的时间复杂度（O(n)）级别。对于添加、删除、查找操作若是要保持较低的时间复杂度可以采用二叉搜索树来实现。 二叉搜索树又称二叉排序树，其节点之间按照一定的顺序进行排放可以极大地提高查找的效率，由于是树形结构，其在添加和删除操作上面的操作不像数组一样需要进行元素的复制。 建立一个BST树的过程，首先添加的是根部节点，然后新添加
173. Binary Search Tree Iterator
BJUT_bluecat的博客
07-11 254
/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ class BSTIte...
二叉搜索树(二叉排序树,二叉查找树)BST
jerryzcx的专栏
03-24 477
binary_search_tree typedef struct btree{ int data; btree *left,*right; }btree inorder preorder postorder int inorder(btree* t) { if(t!=null) { inorder(t->left); cout>>t->data; inorder(t-
数据结构-二叉搜索树/二叉排序树/二叉查找树
pre_tender的博客
10-29 2548
文章目录二叉搜索树/二叉排序树/二叉查找树.1 定义.2 性质二叉搜索树创建二叉搜索树查找.1 查找步骤.2 查找性能分析二叉树插入与删除 二叉搜索树/二叉排序树/二叉查找树 .1 定义 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。。设x为二叉查找树中的一个节点，x节点包含关键字key，节点x的key值记为key[x]。如...
二叉搜索树/二叉排序树/二叉查找树
further_的博客
09-01 2156
怕
二叉排序树的查找与操作详解
本文主要介绍了二叉排序树（Binary Sort Tree, BST）的基本操作，包括查找、插入和删除节点，以及以括号表示法输出树的结构。代码使用C语言编写，适合初学者学习理解。 在二叉排序树中，每个节点的值都大于其左子树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值