二叉查找树 C++实现（含完整代码）

最新推荐文章于 2024-09-04 09:24:20 发布
最新推荐文章于 2024-09-04 09:24:20 发布
阅读量1.3k 收藏 5
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014550279/article/details/50537727
版权
       一般二叉树的查找是通过遍历整棵二叉树实现，效率较低。二叉查找树是一种特殊的二叉树，可以提高查找的效率。二叉查找树又称为二叉排序树或二叉搜索树。

    二叉查找树的定义

       二叉排序树（Binary Search Tree）又称二叉排序树（Binary Sort Tree）,或者是一颗空二叉树，或者是具有一下特性的二叉树：

  1. 　　若它的左子树不为空，则左子树上的所有结点的值均小于根节点的值。
  2. 　　若它的右子树不为空，则右子树上的所有结点的值均小于根节点的值。
  3.       它的左右子树又分别是二叉排序树。

　　由定义可知，二叉查找树中结点的值不允许重复。图a是一棵二叉查找树。当加入结点90后如图b，图b的二叉树不是二叉查找树，因其不满足二叉排序树的特性1.

                                           

　　   图a                                                               图b

   二叉树的C++实现

  1. 二叉查找树的结点结构
template<typename T>
//树结点结构
class BSTNode{
public:
    T _key; //关键在字（键值）
    BSTNode *_lchild; //左孩
    BSTNode *_rchild; //右孩
    BSTNode *_parent; // 双亲
    
    //构造函数
    BSTNode(T key ,BSTNode *lchild,BSTNode *rchild,BSTNode *parent):
    _key(key),_lchild(lchild),_rchild(rchild),_parent(parent){};
};

结点结构BSTNode中含有三个指针域，分别是：

  1. _lchild，指向结点的左孩子。
  2. _rchild，指向结点的右孩子。
  3. _parent，指向结点的双亲。

包含一个数据域 _key，为结点的关键字值。

使用构造函数初始化表列对以上四个数据进行初始化。

  2. 二叉查找树的操作

 

template<typename T>
class BSTree{
private:
    BSTNode<T> *_Root ;  //根结点

public:
    BSTree():_Root(NULL){};
    ~BSTree(){};

    
    void insert (T key);//二叉树的插入

    BSTNode<T>* search (T key)  ;//二叉树的查找
    
    void preOrder()  ;  //先序输出
    void inOrder() ;   //中序输出
    void postOrder() ; //后序输出

    BSTNode<T>* minimumNode();//查找最小的节点
    BSTNode<T>* maximumNode ();//查找最大的节点
    
    T minimumKey();//查找最小的键值
    T maximumKey();//查找最小的键值

    void print();//打印二叉树
    void remove(T key);

    BSTNode<T>* predecessor(BSTNode<T>* x);//查找某个结点的前驱
    BSTNode<T>* sucessor(BSTNode<T>* x); //查找某个结点的后继

    void destory ();

    //内部使用函数，供外部接口调用
private:
    void insert(BSTNode<T>* &tree,BSTNode<T>* z);
    BSTNode<T>* search(BSTNode<T>* &tree,T key) const;
    void preOrder(BSTNode<T>*&tree) const;
    void inOrder(BSTNode<T>*&tree) const;
    void postOrder(BSTNode<T>*&tree) const;
    BSTNode<T>* minimumNode(BSTNode<T> *&tree);
    BSTNode<T>* maximumNode (BSTNode<T> *&tree);
    void print(BSTNode<T>*& tree);
    BSTNode<T>* remove(BSTNode<T>* &tree, BSTNode<T> *z);
    void destory(BSTNode<T>*& tree);
};

BSTree类包含了一个BSTNode指针数据成员，代表二叉查找树的根结点。类种封装了二叉查找树常用的操作接口，包括：

  1. 插入操作：也是建立二叉查找树的方法。
  2. 遍历算法：包括前序、中序、后序（递归实现）。
  3. 查找操作：包括查找某个结点、查找最小结点、查找最大结点、查找最小值、查找最大值。
  4. 删除操作。
  5. 销毁操作。
  6. 打印操作：打印说明二叉树的结构。

BSTree类大部分的函数都有两个重载版本，一个仅供类内部使用（privata声明），另一个则为类用户使用的公用接口（public声明）。

2.1二叉查找树的遍历

　　2.1.1遍历二叉树

 　　遍历二叉树是指从根结点出发，按照某种次序访问二叉树所有结点，使得每个结点被且仅被访问一次，这里的访问可以是输出、比较、更新、查看结点信息等各种操作。遍历是二叉树的一类重要操作，也是二叉树的其他一些操作和各种应用算法的基本框架。用V表示根节点，用L表示左孩子，用R表示右孩子，且规定先L后R的访问顺序，则有VLR（前序）、LVR（中序）、LRV（后续）三种遍历算法。对于图a中的二叉树，其遍历结果为：

　　

　　前序遍历：88 47 19 55 50 98

　　中序遍历：19 47 50 55 88 98 

　　后序遍历：19 50 55 47 98 88

下面来看BSTtree提供的三种遍历接口：

　　前序遍历：

        1. 访问根节点。
        2. 遍历访问左子树。
        3. 遍历访问右子树。
/*
*
*前序遍历算法
*BSTree类内部调用函数
*
*/
template<typename T>
void BSTree<T>::preOrder(BSTNode<T>*&tree) const
{
    if(tree)
    {
        cout<<tree->_key<<" ";
        preOrder(tree->_lchild);
        preOrder(tree->_rchild);
    }
}

/*
*接口
*
*/template<typename T>
void BSTree<T>::postOrder()
{
    postOrder(_Root);
}
 

 

 　　

　　中序遍历：

      1. 遍历访问左子树
      2. 访问根节点。
      3. 遍历访问右子树。

 

/*
*
*中序遍历算法
*类内部调用函数
*
*/
template <typename T>
void BSTree<T>::inOrder(BSTNode<T>*&tree) const
{
    if(tree)
    {
        inOrder(tree->_lchild);
        cout<<tree->_key<<" ";
        inOrder(tree->_rchild);
    }
}

/*
*
*接口
*
*/
template<typename T>
void BSTree<T>::inOrder()
{
    inOrder(_Root);
}

 

　后序遍历：

      1. 遍历访问左子树。
      2. 遍历访问右子树。
      3. 访问根节点。
/*
*
*后序遍历算法
*类内部调用函数
*
*/
template <typename T>
void BSTree<T>::postOrder(BSTNode<T>*&tree) const
{
    if(tree)
    {
        postOrder(tree->_lchild);
        postOrder(tree->_rchild);
        cout<<tree->_key<<" ";
    }
}

/*
*
*接口
*
*/
template<typename T>
void BSTree<T>::postOrder()
{
    postOrder(_Root);
}

 

　　2.2二叉查找树的插入

　　构建查找二叉树通过二叉查找树的插入操作来进行。插入时严格按照查找二叉树的定义来进行，其插入算法的基本过程可以分解为：

    1. 根结点为空则进行插入。
    2. 值比根结点小，在根结点的左子树进行插入。
    3. 值比根结点大，在根节点的右子树进行插入。

　　本文采用非递归算法实现插入操作。

/*
*插入操作
*非递归实现
*内部使用函数
*/
template<typename T>
void BSTree<T> ::insert(BSTNode<T>* &tree,BSTNode<T>* z)
{
    BSTNode<T>* parent = NULL;
    BSTNode<T>* temp = tree;

    //寻找插入点
    while(temp!=NULL)
    {
        parent= temp;
        if(z->_key>temp->_key)
            temp= temp->_rchild;
        else 
            temp=temp->_lchild;
    }
    z->_parent = parent;
    if(parent==NULL) //如果树本来就是空树，则直接把z节点插入根节点
        tree = z;
    else if(z->_key>parent->_key) //如果z的值大于其双亲，则z为其双亲的右孩
        parent->_rchild = z;
    else                          
        parent->_lchild = z;
}
/*
*
*接口
*/
template <typename T>
void BSTree<T>::insert(T key)
{
    //创建一个新的节点，使用构造函数初始化
    BSTNode<T>* z= new BSTNode<T>(key,NULL,NULL,NULL);
    if(!z) //如果创建失败则返回
        return ;
    //调用内部函数进行插入
    insert(_Root,z);
}

 　　2.3 二叉查找树的查找

　　  　　2.3.1 查找某个值的结点

　　　　　这里提供递归与非递归算法实现查找操作。

/*
*查找操作
*非递归实现
*内部使用函数
*/
template <typename T>
BSTNode<T>*  BSTree<T>::search(BSTNode<T>* &tree,T key) const
{
    BSTNode<T>* temp = tree;
    while(temp != NULL)
    {
        if(temp->_key == key)
            return temp;
        else if(temp->_key>key)
            temp = temp->_lchild;
        else
            temp = temp->_rchild;
    }
    return NULL;
}
////查找算法的递归实现
//template<typename T>
//BSTNode<T>* BSTree<T>::search( BSTNode<T>* &tree,T key) const
//{
//    if(!tree)
//    {
//        if(tree->_key==key)
//            return tree;
//        if(tree->_key>key)
//            return search(tree->_lchild,key);
//        if(tree->_key<z->_key)
//            return search(tree->_rchild,key);
//    }
//    return NULL;
//}

/*
*接口
*/
template <typename T>
BSTNode<T> * BSTree<T>::search(T key) 
{
    return search(_Root,key);
}

 　　2.3.2查找二叉查找树值最小的结点

/*
*
*查找最小的结点
*内部调用函数
*
*/
template <typename T>
BSTNode<T>* BSTree<T>::minimumNode(BSTNode<T>*&tree)
{
    BSTNode<T>* temp = tree;
    while(temp->_lchild)
    {
        temp= temp->_lchild;
    }
    return temp;
}

/*
*接口
*/
template<typename T>
BSTNode<T>* BSTree<T>::minimumNode()
{
    return minimumNode(_Root);
}

　　2.3.3查找二叉查找树中值最大的结点

/*
*
*查找键值最大的节点
*内部调用函数
*非递归实现
*/
template<typename T>
BSTNode<T>* BSTree<T>::maximumNode(BSTNode<T>* &tree)
{
    BSTNode<T>* temp=tree;
    while(temp->_rchild)
    {
        temp= temp->_rchild;
    }

    return temp;
}

/*
*接口
*/
template<typename T>
BSTNode<T>* BSTree<T>::maximumNode()
{
    return maximumNode(_Root);
}

 　　2.3.4查找二叉查找树中最小的值

/*
*
*查找最小的键值
*外部接口函数
*调用内部函数minimumNode实现
*/
template<typename T>
T BSTree<T>::minimumKey()
{
    BSTNode<T> *temp = minimumNode(_Root);
    return temp->_key;
}

　　2.4.5查找二叉查找树中最大的值

/*
*
*查找最大的键值
*外部接口函数
*调用内部函数maximumKey
*/
template<typename T>
T BSTree<T>::maximumKey()
{
    BSTNode<T> *temp = maximumNode(_Root);
    return temp->_key;
}

　　2.3打印查找二叉树

　　该操作把二叉树中每个结点的父结点、左右孩子结点的信息描述出来。

/*
*
*打印函数
*打印出平衡二叉树
*BStree内部函数
*/
template<typename T>
void BSTree<T>::print(BSTNode<T>*& tree)
{
    if(tree) //如果tree不为空
    {
        if(tree->_lchild) //结点有左孩子
        {
            cout<<"节点"<<tree->_key<<"有左孩子为"<<tree->_lchild->_key<<endl;
        }
        else 
            cout<<"节点"<<tree->_key<<"无左孩子"<<endl;
        if(tree->_rchild)
        {
            cout<<"节点"<<tree->_key<<"有右孩子为"<<tree->_rchild->_key<<endl;
        }
        else 
            cout<<"节点"<<tree->_key<<"无右孩子"<<endl;
        print(tree->_lchild);
        print(tree->_rchild);
    }
}

/*
*接口
*/
template<typename T>
void BSTree<T>::print()
{
    print(_Root);
}

　　2.4查找给定结点的前驱结点

/*
*查找某个节点x的前驱
*
*接口
*
*/

template <typename T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T>* x)
{

    //如果x是最小的结点，则它没有前驱
    if(x->_key == minimumNode(_Root)->_key)
        return NULL;
    
    //否则
    //先获取二叉树中键值与x的键值相同的结点y
    BSTNode <T> * y = NULL;
    y = search(_Root,x->_key);
    if(y==NULL) return NULL;

    //如果y有左孩子，则x的前驱为“以x的左孩为根的子树的最大结点”
    if(y->_lchild!=NULL)
        return maximumNode(y->_lchild);

    //如果y没有左孩子，则x有两种可能：
    //1.y是一个右孩子，此时x的前驱为其双亲节点
    BSTNode<T>* parent = y->_parent;
    if(parent->_rchild == y)
        return parent;

    //2.y是一个左孩子，则其前驱为其双亲结点中“第一个拥有右孩子结点”的结点
    while(parent!=NULL&&parent->_rchild==NULL)
    {
        parent=parent->_parent;
    }
    return parent;
}

　　2.5查找给定结点的后继结点

/*
*查找某个节点x的后继
*
*外部调用接口
*
*/
template <typename T>
BSTNode<T>* BSTree<T>::sucessor(BSTNode<T>* x)
{
    //如果x是键值最大的，则x没有后继结点
    if(x->_key==maximumNode(_Root)->_key)
        return NULL;

    //获取x在二叉树中的结点y
    BSTNode<T>* y  = NULL;
    y = search(_Root,x->_key);
    if(!y)              //若二叉树没有此结点
        return NULL;

    //如果y有右孩子，则y的后继为其右孩子的最小结点
    if(y->_rchild!=NULL)
        return minimumNode(y->_rchild);

    //如果y没有右孩子，则可分为两种情况：
    //1.y 是左孩子。此时y的后继为y的父结点
    BSTNode <T>* parent = y->_parent;
    if(y->_parent->_lchild == y)
        return parent;

    //2.y是右孩子。此时y的后继结点为“第一个拥有左孩且不是y的直接双亲”的结点
    while(parent!=NULL)
    {
        if(parent->_lchild!=NULL&&parent!=y->_parent)
            return parent;
        parent=parent->_parent;
    }
    return NULL;
}

2.6 删除结点

/*
*
*删除结点
*BSTree类内部调用函数
*
*/
template <class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T>* &tree, BSTNode<T> *z)
{
    BSTNode<T> *x=NULL;
    BSTNode<T> *y=NULL;

    if ((z->_lchild == NULL) || (z->_rchild == NULL) )
        y = z;
    else
        y = sucessor(z);

    if (y->_lchild != NULL)
        x = y->_lchild;
    else
        x = y->_rchild;

    if (x != NULL)
        x->_parent = y->_parent;

    if (y->_parent == NULL)
        tree = x;
    else if (y == y->_parent->_lchild)
        y->_parent->_lchild = x;
    else
        y->_parent->_rchild= x;

    if (y != z) 
        z->_key = y->_key;

    return y;

}

/*
* 接口
*/
template<typename T>
void BSTree<T>::remove(T key)
{
    BSTNode<T> *z, *node; 
    if ((z = search(_Root, key)) != NULL)
        if ( (node = remove(_Root, z)) != NULL)
            delete node;
}

2.7销毁二叉查找树

/*
*
*销毁查找二叉树
*内部调用函数
*
*/
template<typename T>
void BSTree<T>::destory(BSTNode<T>*& tree)
{
    if(tree->_lchild!=NULL)
        destory(tree->_lchild);
    if(tree->_rchild!=NULL)
        destory(tree->_rchild);
    if(tree->_lchild==NULL&&tree->_rchild==NULL)
    {
        delete(tree);
        tree = NULL;
    }
}

/*
*接口
*/
template<typename T>
void BSTree<T>::destory()
{
    destory(_Root);
}
二叉查找树的C++实现（完整源码）

 

#ifndef _BINARY_SEARCH_TREE_
#define _BINARY_SEARCH_TREE_
#include <iostream>
using namespace std;
template<typename T>
//树结点结构
class BSTNode{
public:
    T _key; //关键在字（键值）
    BSTNode *_lchild; //左孩
    BSTNode *_rchild; //右孩
    BSTNode *_parent; // 双亲
    
    //构造函数
    BSTNode(T key ,BSTNode *lchild,BSTNode *rchild,BSTNode *parent):
    _key(key),_lchild(lchild),_rchild(rchild),_parent(parent){};
};


template<typename T>
class BSTree{
private:
    BSTNode<T> *_Root ;  //根结点

public:
    BSTree():_Root(NULL){};
    ~BSTree(){};

    
    void insert (T key);//二叉树的插入

    BSTNode<T>* search (T key)  ;//二叉树的查找
    
    void preOrder()  ;  //先序输出
    void inOrder() ;   //中序输出
    void postOrder() ; //后序输出

    BSTNode<T>* minimumNode();//查找最小的节点
    BSTNode<T>* maximumNode ();//查找最大的节点
    
    T minimumKey();//查找最小的键值
    T maximumKey();//查找最小的键值

    void print();//打印二叉树
    void remove(T key);

    BSTNode<T>* predecessor(BSTNode<T>* x);//查找某个结点的前驱
    BSTNode<T>* sucessor(BSTNode<T>* x); //查找某个结点的后继

    void destory ();

    //内部使用函数，供外部接口调用
private:
    void insert(BSTNode<T>* &tree,BSTNode<T>* z);
    BSTNode<T>* search(BSTNode<T>* &tree,T key) const;
    void preOrder(BSTNode<T>*&tree) const;
    void inOrder(BSTNode<T>*&tree) const;
    void postOrder(BSTNode<T>*&tree) const;
    BSTNode<T>* minimumNode(BSTNode<T> *&tree);
    BSTNode<T>* maximumNode (BSTNode<T> *&tree);
    void print(BSTNode<T>*& tree);
    BSTNode<T>* remove(BSTNode<T>* &tree, BSTNode<T> *z);
    void destory(BSTNode<T>*& tree);
};

/*
*插入操作
*非递归实现
*内部使用函数
*/
template<typename T>
void BSTree<T> ::insert(BSTNode<T>* &tree,BSTNode<T>* z)
{
    BSTNode<T>* parent = NULL;
    BSTNode<T>* temp = tree;

    //寻找插入点
    while(temp!=NULL)
    {
        parent= temp;
        if(z->_key>temp->_key)
            temp= temp->_rchild;
        else 
            temp=temp->_lchild;
    }
    z->_parent = parent;
    if(parent==NULL) //如果树本来就是空树，则直接把z节点插入根节点
        tree = z;
    else if(z->_key>parent->_key) //如果z的值大于其双亲，则z为其双亲的右孩
        parent->_rchild = z;
    else                          
        parent->_lchild = z;
}
/*
*
*接口
*/
template <typename T>
void BSTree<T>::insert(T key)
{
    //创建一个新的节点，使用构造函数初始化
    BSTNode<T>* z= new BSTNode<T>(key,NULL,NULL,NULL);
    if(!z) //如果创建失败则返回
        return ;
    //调用内部函数进行插入
    insert(_Root,z);
}

/*
*查找操作
*非递归实现
*内部使用函数
*/
template <typename T>
BSTNode<T>*  BSTree<T>::search(BSTNode<T>* &tree,T key) const
{
    BSTNode<T>* temp = tree;
    while(temp != NULL)
    {
        if(temp->_key == key)
            return temp;
        else if(temp->_key>key)d
            temp = temp->_lchild;
        else
            temp = temp->_rchild;
    }
    return NULL;
}
////查找算法的递归实现
//template<typename T>
//BSTNode<T>* BSTree<T>::search( BSTNode<T>* &tree,T key) const
//{
//    if(!tree)
//    {
//        if(tree->_key==key)
//            return tree;
//        if(tree->_key>key)
//            return search(tree->_lchild,key);
//        if(tree->_key<z->_key)
//            return search(tree->_rchild,key);
//    }
//    return NULL;
//}

/*
*接口
*/
template <typename T>
BSTNode<T> * BSTree<T>::search(T key) 
{
    return search(_Root,key);
}
/*
*
*前序遍历算法
*外部使用接口
*
*/
template<typename T>
void BSTree<T>::preOrder(BSTNode<T>*&tree) const
{
    if(tree)
    {
        cout<<tree->_key<<" ";
        preOrder(tree->_lchild);
        preOrder(tree->_rchild);
    }
}
template <typename T>
void BSTree<T>::inOrder(BSTNode<T>*&tree) const
{
    if(tree)
    {
        inOrder(tree->_lchild);
        cout<<tree->_key<<" ";
        inOrder(tree->_rchild);
    }
}
template <typename T>
void BSTree<T>::postOrder(BSTNode<T>*&tree) const
{
    if(tree)
    {
        postOrder(tree->_lchild);
        postOrder(tree->_rchild);
        cout<<tree->_key<<" ";
    }
}
/*
*遍历算法
*分别为前序、中序、后序
*BSTree 类外部接口函数
*
*/
template<typename T>
void BSTree<T>::preOrder()
{
    preOrder(_Root);
}
template<typename T>
void BSTree<T>::inOrder()
{
    inOrder(_Root);
}
template<typename T>
void BSTree<T>::postOrder()
{
    postOrder(_Root);
}
/*
*
*查找最小的结点
*内部调用函数
*
*/
template <typename T>
BSTNode<T>* BSTree<T>::minimumNode(BSTNode<T>*&tree)
{
    BSTNode<T>* temp = tree;
    while(temp->_lchild)
    {
        temp= temp->_lchild;
    }
    return temp;
}

/*
*接口
*/
template<typename T>
BSTNode<T>* BSTree<T>::minimumNode()
{
    return minimumNode(_Root);
}
/*
*
*查找键值最大的节点
*内部调用函数
*非递归实现
*/
template<typename T>
BSTNode<T>* BSTree<T>::maximumNode(BSTNode<T>* &tree)
{
    BSTNode<T>* temp=tree;
    while(temp->_rchild)
    {er
        temp= temp->_rchild;
    }

    return temp;
}

/*
*接口
*/
template<typename T>
BSTNode<T>* BSTree<T>::maximumNode()
{
    return maximumNode(_Root);
}
/*
*
*查找最小的键值
*外部接口函数
*调用内部函数minimumNode实现
*/
template<typename T>
T BSTree<T>::minimumKey()
{
    BSTNode<T> *temp = minimumNode(_Root);
    return temp->_key;
}
/*
* 
*查找最大的键值
*外部接口函数
*调用内部函数maximumKey
*/
template<typename T>
T BSTree<T>::maximumKey()
{
    BSTNode<T> *temp = maximumNode(_Root);
    return temp->_key;
}

/*
*
*打印函数
*打印出平衡二叉树
*BStree内部函数
*/
template<typename T>
void BSTree<T>::print(BSTNode<T>*& tree)
{
    if(tree) //如果tree不为空
    {
        if(tree->_lchild) //结点有左孩子
        {
            cout<<"节点"<<tree->_key<<"有左孩子为"<<tree->_lchild->_key<<endl;
        }
        else 
            cout<<"节点"<<tree->_key<<"无左孩子"<<endl;
        if(tree->_rchild)
        {
            cout<<"节点"<<tree->_key<<"有右孩子为"<<tree->_rchild->_key<<endl;
        }
        else 
            cout<<"节点"<<tree->_key<<"无右孩子"<<endl;
        print(tree->_lchild);
        print(tree->_rchild);
    }
}

/*
*接口
*/
template<typename T>
void BSTree<T>::print()
{
    print(_Root);
}
/*
*查找某个节点x的前驱
*
*外部函数调用
*
*/

template <typename T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T>* x)
{

    //如果x是最小的结点，则它没有前驱
    if(x->_key == minimumNode(_Root)->_key)
        return NULL;
    
    //否则
    //先获取二叉树中键值与x的键值相同的结点y
    BSTNode <T> * y = NULL;
    y = search(_Root,x->_key);
    if(y==NULL) return NULL;

    //如果y有左孩子，则x的前驱为“以x的左孩为根的子树的最大结点”
    if(y->_lchild!=NULL)
        return maximumNode(y->_lchild);

    //如果y没有左孩子，则x有两种可能：
    //1.y是一个右孩子，此时x的前驱为其双亲节点
    BSTNode<T>* parent = y->_parent;
    if(parent->_rchild == y)
        return parent;

    //2.y是一个左孩子，则其前驱为其双亲结点中“第一个拥有右孩子结点”的结点
    while(parent!=NULL&&parent->_rchild==NULL)
    {
        parent=parent->_parent;
    }
    return parent;
}
/*
*查找某个节点x的后继
*
*外部调用接口
*
*/
template <typename T>
BSTNode<T>* BSTree<T>::sucessor(BSTNode<T>* x)
{
    //如果x是键值最大的，则x没有后继结点
    if(x->_key==maximumNode(_Root)->_key)
        return NULL;

    //获取x在二叉树中的结点y
    BSTNode<T>* y  = NULL;
    y = search(_Root,x->_key);
    if(!y)              //若二叉树没有此结点
        return NULL;

    //如果y有右孩子，则y的后继为其右孩子的最小结点
    if(y->_rchild!=NULL)
        return minimumNode(y->_rchild);

    //如果y没有右孩子，则可分为两种情况：
    //1.y 是左孩子。此时y的后继为y的父结点
    BSTNode <T>* parent = y->_parent;
    if(y->_parent->_lchild == y)
        return parent;

    //2.y是右孩子。此时y的后继结点为“第一个拥有左孩且不是y的直接双亲”的结点
    while(parent!=NULL)
    {
        if(parent->_lchild!=NULL&&parent!=y->_parent)
            return parent;
        parent=parent->_parent;
    }
    return NULL;
}
/*
*
*删除结点
*BSTree类内部调用函数
*
*/
template <class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T>* &tree, BSTNode<T> *z)
{
    BSTNode<T> *x=NULL;
    BSTNode<T> *y=NULL;

    if ((z->_lchild == NULL) || (z->_rchild == NULL) )
        y = z;
    else
        y = sucessor(z);

    if (y->_lchild != NULL)
        x = y->_lchild;
    else
        x = y->_rchild;

    if (x != NULL)
        x->_parent = y->_parent;

    if (y->_parent == NULL)
        tree = x;
    else if (y == y->_parent->_lchild)
        y->_parent->_lchild = x;
    else
        y->_parent->_rchild= x;

    if (y != z) 
        z->_key = y->_key;

    return y;

}

/*
* 接口
*/
template<typename T>
void BSTree<T>::remove(T key)
{
    BSTNode<T> *z, *node; 
    if ((z = search(_Root, key)) != NULL)
        if ( (node = remove(_Root, z)) != NULL)
            delete node;
}
/*
*
*销毁查找二叉树
*内部调用函数
*
*/
template<typename T>
void BSTree<T>::destory(BSTNode<T>*& tree)
{
    if(tree->_lchild!=NULL)
        destory(tree->_lchild);
    if(tree->_rchild!=NULL)
        destory(tree->_rchild);
    if(tree->_lchild==NULL&&tree->_rchild==NULL)
    {
        delete(tree);
        tree = NULL;
    }
}

/*
*接口
*/
template<typename T>
void BSTree<T>::destory()
{
    destory(_Root);
}
#endif
BSTree.h
主函数 测试数据
// BSTree.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include <iostream>
#include "BSTree.h"
using namespace std;
int main()
{
    BSTree<int> s ;
    int a ;
    cout<<"请输入二叉树结点以构造二叉查找树："<<endl;
    while(cin>>a )
        s.insert(a);
    cin.clear();

    cout<<"前序遍历二叉查找树:"<<endl;
    s.postOrder();
    cout<<endl;


    cout<<"中序遍历二叉查找树:"<<endl;
    s.inOrder();
    cout<<endl;


    cout<<"后序遍历二叉查找树:"<<endl;
    s.postOrder();
    cout<<endl;


    cout<<"打印二叉查找树"<<endl;
    s.print();

    cout<<"请输入要查找的数："<<endl;

    while(cin>>a)
    {
        BSTNode<int>* findnode = s.search(a);
        if(!findnode)
        {
            cout<<"查找失败"<<endl;
            s.insert(a);
            cout<<"已经将"<<a<<"插入二叉查找树,现在二叉查找树为："<<endl;
            s.inOrder();
            cout<<endl;
        }
        else
        {
            cout<<findnode->_key<<"查找成功"<<endl;
        }
    }
    cin.clear();

    cout<<"请输入结点以查找其前驱节点"<<endl;
    BSTNode<int>* findPreNode= new BSTNode<int>(1,NULL,NULL,NULL);
    while(cin>>findPreNode->_key)
    {
        BSTNode<int>* preNode ;
        if((preNode= s.predecessor(findPreNode))!=NULL)
        {
            cout<<"其前驱结点为：";
            cout<<preNode->_key<<endl;
        }
        else 
            cout<<"没有前驱结点"<<endl;

        if((preNode= s.sucessor(findPreNode))!=NULL)
        {
            cout<<"其后继结点为：";
            cout<<preNode->_key<<endl;
        }
        else 
            cout<<"没有后继结点"<<endl;
    }

    cin.clear();
    cout<<"请输入要删除的结点："<<endl;
    while(cin >>a)
    {

        s.remove(a);
        cout<<"删除后的二叉排序树："<<endl;
        s.inOrder();
    }


    BSTNode<int>* maxNode =  s.minimumNode();
    if(!maxNode)
        cout<<"最小的节点为："<<maxNode->_key<<endl;

    BSTNode<int>* minNode = s.maximumNode();
    if(!minNode)
        cout<<"最大的节点为："<<minNode->_key<<endl;

    cout<<"销毁二叉树"<<endl;
    s.destory();
    s.inOrder();

    system("pause");

    return 0;
}
View Code

运行结果：

 

 

=========================================================================================================================================完。

melonstreet
关注
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1482
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
二叉查找树C++实现
12-23
在学习算法过程中自己的代码实现，与大家分享交流。版权所有:miracledan
C++ 数据结构——二叉树（最最最最最实用的二叉树教程）
最新发布
Ahjol171的博客
09-04 1520
本文介绍了基础二叉树的常见操作与创建，包含代码实现以及其代码逻辑
二叉查找树的实现（c++）
hujian_的专栏
05-10 1048
#ifndef _HJ_STL_BST_H_ #define _HJ_STL_BST_H_ /* * Author:hujian * Time:2016/5/8 * discription:this file is about binary search tree<BST>. * * NOTICE:you should not use hjstl_vector in anywhere. * beca
二叉查找树的C++实现
云飞扬
03-25 495
1.基本概念：二叉查找树是一种有序排列的二叉树，在二叉查找树中，每个节点的左子树的所有元素的值小于该节点的元素的值，而右子树的每个节点的值都大于该节点的值，如果对二叉查找树进行中序遍历，将按照从小到大的顺序输出树里面的所有元素。 2.头文件：BinatyTree.h #ifndef _TREE_H #define _TREE_H #include<iostream> using namespace std; struct TreeNode; typedef int Elemen
C++实现二叉查找树
weixin_38044916的博客
04-18 666
/***********二叉查找树的实现*************/ //节点类 template class TreeNode { public: Type data; TreeNode *left; TreeNode *right; TreeNode() :data(Type()), left(nullptr), right(nullptr){}
二叉查找树 减治法——C++代码
05-24
在C++中实现二叉查找树，一般会定义一个结构体或类来表示树节点，包括键、值和子节点指针。然后，提供一系列成员函数来执行基本操作，如`insert`（插入）、`search`（查找）、`delete`（删除）。以下是C++实现二叉...
二叉查找树的实现
08-25
1、 定义二叉查找树的类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）实现二叉查找树结构； 2） 实现二叉查找树的查找、插入和删除等算法；
c++实现二叉查找树
11-15
本文将详细介绍如何使用C++来实现一个二叉查找树(Binary Search Tree, BST)，包括其基本操作：插入、删除、遍历等，并通过示例代码进行解释。二叉查找树是一种非常重要的数据结构，在计算机科学领域有着广泛的应用，...
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
二叉查找树（二分搜索树）的C++方法实现
01-20
资源内容：完整的二叉查找树C++头文件，包括<<运算符重载，bst类构造器、bst类析构器、destroy()、size()、insert()，迭代器类的声明与实现，++运算符重载（前置、后置）、--运算符重载、*运算符重载、！=运算符重载、begin()、end()、find()、erase()、insertLeaf()、prune()、deleteLink()。（插入节点方法、删除节点的三种情况）。
二叉查找树实现代码
12-09
二叉查找树的插入、搜索、删除、寻找前驱结点、寻找后继结点
二叉搜索树C++代码
07-30
本文主要讨论二叉搜索树的基本性质以及基本操作，并用C++代码实现，每个成员操作以成员函数的形式出现，并附有适当的说明。 包括： 普通二叉树的遍历（先序，中序，后序，分层），二叉搜索树的建立，插值，删值，求前驱，求后继，求size，求最大节点，最小节点
二叉搜索树实现 C++
juggte的博客
12-19 1006
二叉树搜索树（BST） 二叉搜索树是一种二叉树，是应用非常广泛的一种二叉树，英文简称为BST。又称为:二叉查找树、二叉排序树 目录二叉树搜索树（BST）BST的特点SBT的接口C++实现复杂度分析 BST的特点 二叉树搜索树特点 任意一个节点的值都大于其左子树所有节点的值 任意一个节点的值都小于其右子树所有节点的值 SBT的接口 bool add(const T& x) bool remove(const T& x) bool contains(const T& x)
二叉搜索树(C++实现)
qq_56628506的博客
08-22 2955
二叉搜索树初探
数据结构--C++实现二叉查找树
HWQlet的博客
04-18 152
直接上代码，很多解释我都再代码里面有说明，如果有什么问题欢迎交流 #include <iostream> #include <string> #include <utility> #include <algorithm> using namespace std; struct Node { int key; Node * l...
c++实现二叉搜索树
m0_60773087的博客
06-08 515
c++实现二叉搜索树
二叉查找树基础操作实现及C++代码
提供的C++代码详细描述了这些操作的实现。" 在计算机科学中，二叉查找树（Binary Search Tree，BST）是一种自平衡的二叉树数据结构，它满足以下性质： 1. **左子树性质**：对于任意节点，其左子树中的所有节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值