二叉查找树 ——c++实现版本

最新推荐文章于 2024-07-18 22:05:06 发布
最新推荐文章于 2024-07-18 22:05:06 发布
阅读量114 收藏
点赞数
分类专栏： # 常用数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanmartin/article/details/108415480
版权

​​
概要
本章给出二叉查找树的C++版本。这里不再对树的相关概念进行介绍，若遇到不明白的概念，可以在上一章查找。

文章目录

二叉查找树简介

二叉查找树(Binary Search Tree)，又称为二叉搜索树。

它是特殊的二叉树：对于二叉树，假设x为二叉树中的任意一个结点，x节点包含关键字key,节点x的key值为key[x]。如y是x的左子树中的一个结点，则key[y] <= key[x]；如y是x的右子树的一个结点，则key[y] >= key[x]。那么这颗树就是二叉查找树.
在这里插入图片描述
在二叉查找树中：
(01) 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
(02) 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
(03) 任意节点的左、右子树也分别为二叉查找树。
(04) 没有键值相等的节点（no duplicate nodes）

二叉查找树的C++实现

1. 节点和二叉查找树的定义

1.1 二叉查找树节点

template<class T>
class BSTNode
{
    public:
        T key;
        BSTNode *left;
        BSTNode *right;
        BSTNode *parent;
 
        BSTNode(T value,BSTNode * p,BSTNode * r,BSTNode* l,BSTNode* r) :
            key(value),parent(),left(l),right(r) {}
};

BSTNode是二叉查找树的节点，它包含二叉树的几个基本信息
key – 它是关键字，是用来对二叉查找树的节点进行排序的；
left --它指向当前节点的左孩子；
right --它指向当前节点的右孩子；
parent --它指向当前节点的父结点。

1.2 二叉树操作

template <class T>
class BSTree {
    private:
        BSTNode<T> *mRoot;    // 根结点
 
    public:
        BSTree();
        ~BSTree();
 
        // 前序遍历"二叉树"
        void preOrder();
        // 中序遍历"二叉树"
        void inOrder();
        // 后序遍历"二叉树"
        void postOrder();
 
        // (递归实现)查找"二叉树"中键值为key的节点
        BSTNode<T>* search(T key);
        // (非递归实现)查找"二叉树"中键值为key的节点
        BSTNode<T>* iterativeSearch(T key);
 
        // 查找最小结点：返回最小结点的键值。
        T minimum();
        // 查找最大结点：返回最大结点的键值。
        T maximum();
 
        // 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
        BSTNode<T>* successor(BSTNode<T> *x);
        // 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
        BSTNode<T>* predecessor(BSTNode<T> *x);
 
        // 将结点(key为节点键值)插入到二叉树中
        void insert(T key);
 
        // 删除结点(key为节点键值)
        void remove(T key);
 
        // 销毁二叉树
        void destroy();
 
        // 打印二叉树
        void print();
    private:
        // 前序遍历"二叉树"
        void preOrder(BSTNode<T>* tree) const;
        // 中序遍历"二叉树"
        void inOrder(BSTNode<T>* tree) const;
        // 后序遍历"二叉树"
        void postOrder(BSTNode<T>* tree) const;
 
        // (递归实现)查找"二叉树x"中键值为key的节点
        BSTNode<T>* search(BSTNode<T>* x, T key) const;
        // (非递归实现)查找"二叉树x"中键值为key的节点
        BSTNode<T>* iterativeSearch(BSTNode<T>* x, T key) const;
 
        // 查找最小结点：返回tree为根结点的二叉树的最小结点。
        BSTNode<T>* minimum(BSTNode<T>* tree);
        // 查找最大结点：返回tree为根结点的二叉树的最大结点。
        BSTNode<T>* maximum(BSTNode<T>* tree);
 
        // 将结点(z)插入到二叉树(tree)中
        void insert(BSTNode<T>* &tree, BSTNode<T>* z);
 
        // 删除二叉树(tree)中的结点(z)，并返回被删除的结点
        BSTNode<T>* remove(BSTNode<T>* &tree, BSTNode<T> *z);
 
        // 销毁二叉树
        void destroy(BSTNode<T>* &tree);
 
        // 打印二叉树
        void print(BSTNode<T>* tree, T key, int direction);
};

BSTree是二叉树。它包含二叉查找树的根节点和二叉查找树的操作。二叉查找树的操作中有许多重载函数，例如insert()函数，其中一个是内部接口，另一个是提供给外部的接口。

2 遍历

这里讲解前序遍历、中序遍历、后序遍历三种方式：

2.1 前序遍历

若二叉 树非空，则执行如下操作：

  1、访问根节点；

   2、先序遍历左子树；

   3、先序遍历右子树

 前序遍历代码：   

	template <class T>
void BSTree<T>::preOrder(BSTNode<T>* tree) const
{
 if(tree != NULL)
 {
     cout<< tree->key << " " ;
     preOrder(tree->left);
     preOrder(tree->right);
 }
}

template <class T>
void BSTree<T>::preOrder() 
{
 preOrder(mRoot);
}

2.2 中序遍历

 若二叉树非空，则执行如下操作：

  （1）遍历左子树；

   （2）访问根节点；

   （3）遍历右子树

中序遍历代码：

template<class T>
void BSTree<T>::inOrder(BSTree<T>* tree) const
{
 if(NULL != tree)
 {
     inOrder(tree->left);
     std::cout << tree->key << " " << std::endl;
     inOrder(tree->right);
 }

}

template<class T>
void BSTree<T>::inOrder()
{
 inOrder(mRoot);
}

2.3 后序遍历

若二叉树非空，则执行以下操作：
(01) 后序遍历左子树；
(02) 后序遍历右子树；
(03) 访问根结点。

后序遍历代码:

template <class T>
void BSTree<T>::postOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        postOrder(tree->left);
        postOrder(tree->right);
        cout<< tree->key << " " ;
    }
}
 
template <class T>
void BSTree<T>::postOrder() 
{
    postOrder(mRoot);
}

看看下面这颗树的各种遍历方式：
在这里插入图片描述
对于上面的二叉树而言，
(01) 前序遍历结果： 3 1 2 5 4 6
(02) 中序遍历结果： 1 2 3 4 5 6
(03) 后序遍历结果： 2 1 4 6 5 3

3、查找

递归版本的代码:

	template<class T>
 BSTNode<T>* BSTree<T>::search(BSTNode<T>* x,T key) const 
 {
     if(NULL == x || x->key == key)
     {
         return x;
     }
     
     if(key < x->key)
     {
         return search(x->left,key);
     }
     else
     {
         return search(x->right,key);
     }
 }
  
 template<class T>
 BSTNode<T>* BSTree<T>::search(T key)
 {
     return search(mRoot,key);
 }

非递归版本

	template <class T>
 BSTNode<T>* BSTree<T>::iterativeSearch(BSTNode<T>* x, T key) const
 {
     while ((x!=NULL) && (x->key!=key))
     {
         if (key < x->key)
             x = x->left;
         else
             x = x->right;
     }
  
     return x;
 }
  
 template <class T>
 BSTNode<T>* BSTree<T>::iterativeSearch(T key)
 {
     iterativeSearch(mRoot, key);
 }

4、最大值和最小值

4.1 查找最大值代码：

template<class T>
BSTNode<T>* BSTree<T>::maximum(BSTNode<T>* tree)
{
    if(NULL == tree)
    {
        return tree;
    }
 
    while(tree->right)
    {
        tree = tree->right;
    }
 
    return tree;
}
 
template <class T>
T BSTree<T>::maximum()
{
    BSTNode<T> *p = maximum(mRoot);
    if (p != NULL)
        return p->key;
 
    return (T)NULL;
}

4.2 查看最小值的代码：

template<class T>
BSTNode<T>* BSTree<T>::minmum(BSTNode<T>* tree)
{
    if(NULL == tree)
    {
        return tree;
    }
 
    while(tree->left)
    {
        tree = tree->left;
    }
 
    return tree;
}
 
template <class T>
T BSTree<T>::minmum()
{
    BSTNode<T> *p = minmum(mRoot);
    if (p != NULL)
        return p->key;
 
    return (T)NULL;
}

5. 前驱和后继

节点的前驱：是该节点的左子树中的最大节点。
节点的后继：是该节点的右子树中的最小节点。

查找前驱节点的代码:

/* 
* 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
*/

template <class T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T> *x)
{
 // 如果x存在左孩子，则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
 if (x->left != NULL)
     return maximum(x->left);

 // 如果x没有左孩子。则x有以下两种可能：
 // (01) x是"一个右孩子"，则"x的前驱结点"为 "它的父结点"。
 // (01) x是"一个左孩子"，则查找"x的最低的父结点，并且该父结点要具有右孩子"，找到的这个"最低的父结点"就是"x的前驱结点"。
 BSTNode<T>* y = x->parent;
 while ((y!=NULL) && (x==y->left))
 {
     x = y;
     y = y->parent;
 }

 return y;
}

查找后继节点的代码:

/* 
* 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
*/
template <class T>
BSTNode<T>* BSTree<T>::successor(BSTNode<T> *x)
{
  // 如果x存在右孩子，则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
  if (x->right != NULL)
      return minimum(x->right);

  // 如果x没有右孩子。则x有以下两种可能：
  // (01) x是"一个左孩子"，则"x的后继结点"为 "它的父结点"。
  // (02) x是"一个右孩子"，则查找"x的最低的父结点，并且该父结点要具有左孩子"，找到的这个"最低的父结点"就是"x的后继结点"。
  BSTNode<T>* y = x->parent;
  while ((y!=NULL) && (x==y->right))
  {
      x = y;
      y = y->parent;
  }

  return y;
}

6. 插入

插入节点的代码

	/* 
* 将结点插入到二叉树中
*
* 参数说明：
*     tree 二叉树的根结点
*     z 插入的结点
*/
template <class T>
void BSTree<T>::insert(BSTNode<T>* &tree, BSTNode<T>* z)
{
 BSTNode<T> *y = NULL;
 BSTNode<T> *x = tree;

 // 查找z的插入位置
 while (x != NULL)
 {
     y = x;
     if (z->key < x->key)
         x = x->left;
     else
         x = x->right;
 }

 z->parent = y;
 if (y==NULL)
     tree = z;
 else if (z->key < y->key)
     y->left = z;
 else
     y->right = z;
}

/* 
* 将结点(key为节点键值)插入到二叉树中
*
* 参数说明：
*     tree 二叉树的根结点
*     key 插入结点的键值
*/
template <class T>
void BSTree<T>::insert(T key)
{
 BSTNode<T> *z=NULL;

 // 如果新建结点失败，则返回。
 if ((z=new BSTNode<T>(key,NULL,NULL,NULL)) == NULL)
     return ;

 insert(mRoot, z);
}

注：本文实现的二叉查找树是允许插入相同键值的节点的。若想禁止二叉查找树中插入相同键值的节点，可以参考"二叉查找树(一)之 图文解析 和 C语言的实现"中的插入函数进行修改。

7. 删除

删除节点的代码

/* 
 * 删除结点(z)，并返回被删除的结点
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 删除的结点
 */
 
template<class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T>* & tree,BSTNode<T> *z)
{
    BSTNode<T> *x=NULL;
    BSTNode<T> *y=NULL;
    
    if ((z->left == NULL) || (z->right == NULL) )
        y = z;
    else
        y = successor(z);
 
    if (y->left != NULL)
        x = y->left;
    else
        x = y->right;
 
    if (x != NULL)
        x->parent = y->parent;
 
    if (y->parent == NULL)
        tree = x;
    else if (y == y->parent->left)
        y->parent->left = x;
    else
        y->parent->right = x;
 
    if (y != z) 
        z->key = y->key;
 
    return y;
}
 
/* 
 * 删除结点(z)，并返回被删除的结点
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 删除的结点
 */
template <class T>
void BSTree<T>::remove(T key)
{
    BSTNode<T> *z, *node; 
 
    if ((z = search(mRoot, key)) != NULL)
        if ( (node = remove(mRoot, z)) != NULL)
            delete node;
}
  1. 打印

打印二叉查找树的代码

/*

  • 打印"二叉查找树"
  • key – 节点的键值
  • direction – 0，表示该节点是根节点;
  •           -1，表示该节点是它的父结点的左孩子;

  •            1，表示该节点是它的父结点的右孩子。

/
template
void BSTree::print(BSTNode tree, T key, int direction)
{
if(tree != NULL)
{
if(direction0) // tree是根节点
cout << setw(2) << tree->key << " is root" << endl;
else // tree是分支节点
cout << setw(2) << tree->key << " is " << setw(2) << key << "'s " << setw(12) << (direction1?“right child” : “left child”) << endl;

    print(tree->left, tree->key, -1);
    print(tree->right,tree->key,  1);
}

}

template
void BSTree::print()
{
if (mRoot != NULL)
print(mRoot, mRoot->key, 0);
}

9. 销毁

销毁二叉查找树的代码

/*
 * 销毁二叉树
 */
template <class T>
void BSTree<T>::destroy(BSTNode<T>* &tree)
{
    if (tree==NULL)
        return ;
 
    if (tree->left != NULL)
        return destroy(tree->left);
    if (tree->right != NULL)
        return destroy(tree->right);
 
    delete tree;
    tree=NULL;
}
 
template <class T>
void BSTree<T>::destroy()
{
    destroy(mRoot);
}

二叉查找树的C++实现(完整源码)

二叉查找树的C++实现文件(BSTree.h)

/**
 * C++ 语言: 二叉查找树
 *
 * @author skywang
 * @date 2013/11/07
 */
 
#ifndef _BINARY_SEARCH_TREE_HPP_
#define _BINARY_SEARCH_TREE_HPP_
 
#include <iomanip>
#include <iostream>
using namespace std;
 
template <class T>
class BSTNode{
    public:
        T key;            // 关键字(键值)
        BSTNode *left;    // 左孩子
        BSTNode *right;    // 右孩子
        BSTNode *parent;// 父结点
 
        BSTNode(T value, BSTNode *p, BSTNode *l, BSTNode *r):
            key(value),parent(),left(l),right(r) {}
};
 
template <class T>
class BSTree {
    private:
        BSTNode<T> *mRoot;    // 根结点
 
    public:
        BSTree();
        ~BSTree();
 
        // 前序遍历"二叉树"
        void preOrder();
        // 中序遍历"二叉树"
        void inOrder();
        // 后序遍历"二叉树"
        void postOrder();
 
        // (递归实现)查找"二叉树"中键值为key的节点
        BSTNode<T>* search(T key);
        // (非递归实现)查找"二叉树"中键值为key的节点
        BSTNode<T>* iterativeSearch(T key);
 
        // 查找最小结点：返回最小结点的键值。
        T minimum();
        // 查找最大结点：返回最大结点的键值。
        T maximum();
 
        // 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
        BSTNode<T>* successor(BSTNode<T> *x);
        // 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
        BSTNode<T>* predecessor(BSTNode<T> *x);
 
        // 将结点(key为节点键值)插入到二叉树中
        void insert(T key);
 
        // 删除结点(key为节点键值)
        void remove(T key);
 
        // 销毁二叉树
        void destroy();
 
        // 打印二叉树
        void print();
    private:
        // 前序遍历"二叉树"
        void preOrder(BSTNode<T>* tree) const;
        // 中序遍历"二叉树"
        void inOrder(BSTNode<T>* tree) const;
        // 后序遍历"二叉树"
        void postOrder(BSTNode<T>* tree) const;
 
        // (递归实现)查找"二叉树x"中键值为key的节点
        BSTNode<T>* search(BSTNode<T>* x, T key) const;
        // (非递归实现)查找"二叉树x"中键值为key的节点
        BSTNode<T>* iterativeSearch(BSTNode<T>* x, T key) const;
 
        // 查找最小结点：返回tree为根结点的二叉树的最小结点。
        BSTNode<T>* minimum(BSTNode<T>* tree);
        // 查找最大结点：返回tree为根结点的二叉树的最大结点。
        BSTNode<T>* maximum(BSTNode<T>* tree);
 
        // 将结点(z)插入到二叉树(tree)中
        void insert(BSTNode<T>* &tree, BSTNode<T>* z);
 
        // 删除二叉树(tree)中的结点(z)，并返回被删除的结点
        BSTNode<T>* remove(BSTNode<T>* &tree, BSTNode<T> *z);
 
        // 销毁二叉树
        void destroy(BSTNode<T>* &tree);
 
        // 打印二叉树
        void print(BSTNode<T>* tree, T key, int direction);
};
 
/*
 * 构造函数
 */
template <class T>
BSTree<T>::BSTree():mRoot(NULL)
{
}
 
/*
 * 析构函数
 */
template <class T>
BSTree<T>::~BSTree()
{
    destroy();
}
 
/*
 * 前序遍历"二叉树"
 */
template <class T>
void BSTree<T>::preOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        cout<< tree->key << " " ;
        preOrder(tree->left);
        preOrder(tree->right);
    }
}
 
template <class T>
void BSTree<T>::preOrder()
{
    preOrder(mRoot);
}
 
/*
 * 中序遍历"二叉树"
 */
template <class T>
void BSTree<T>::inOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        inOrder(tree->left);
        cout<< tree->key << " " ;
        inOrder(tree->right);
    }
}
 
template <class T>
void BSTree<T>::inOrder()
{
    inOrder(mRoot);
}
 
/*
 * 后序遍历"二叉树"
 */
template <class T>
void BSTree<T>::postOrder(BSTNode<T>* tree) const
{
    if(tree != NULL)
    {
        postOrder(tree->left);
        postOrder(tree->right);
        cout<< tree->key << " " ;
    }
}
 
template <class T>
void BSTree<T>::postOrder()
{
    postOrder(mRoot);
}
 
/*
 * (递归实现)查找"二叉树x"中键值为key的节点
 */
template <class T>
BSTNode<T>* BSTree<T>::search(BSTNode<T>* x, T key) const
{
    if (x==NULL || x->key==key)
        return x;
 
    if (key < x->key)
        return search(x->left, key);
    else
        return search(x->right, key);
}
 
template <class T>
BSTNode<T>* BSTree<T>::search(T key)
{
    search(mRoot, key);
}
 
/*
 * (非递归实现)查找"二叉树x"中键值为key的节点
 */
template <class T>
BSTNode<T>* BSTree<T>::iterativeSearch(BSTNode<T>* x, T key) const
{
    while ((x!=NULL) && (x->key!=key))
    {
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }
 
    return x;
}
 
template <class T>
BSTNode<T>* BSTree<T>::iterativeSearch(T key)
{
    iterativeSearch(mRoot, key);
}
 
/*
 * 查找最小结点：返回tree为根结点的二叉树的最小结点。
 */
template <class T>
BSTNode<T>* BSTree<T>::minimum(BSTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;
 
    while(tree->left != NULL)
        tree = tree->left;
    return tree;
}
 
template <class T>
T BSTree<T>::minimum()
{
    BSTNode<T> *p = minimum(mRoot);
    if (p != NULL)
        return p->key;
 
    return (T)NULL;
}
 
/*
 * 查找最大结点：返回tree为根结点的二叉树的最大结点。
 */
template <class T>
BSTNode<T>* BSTree<T>::maximum(BSTNode<T>* tree)
{
    if (tree == NULL)
        return NULL;
 
    while(tree->right != NULL)
        tree = tree->right;
    return tree;
}
 
template <class T>
T BSTree<T>::maximum()
{
    BSTNode<T> *p = maximum(mRoot);
    if (p != NULL)
        return p->key;
 
    return (T)NULL;
}
 
/*
 * 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
 */
template <class T>
BSTNode<T>* BSTree<T>::successor(BSTNode<T> *x)
{
    // 如果x存在右孩子，则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
    if (x->right != NULL)
        return minimum(x->right);
 
    // 如果x没有右孩子。则x有以下两种可能：
    // (01) x是"一个左孩子"，则"x的后继结点"为 "它的父结点"。
    // (02) x是"一个右孩子"，则查找"x的最低的父结点，并且该父结点要具有左孩子"，找到的这个"最低的父结点"就是"x的后继结点"。
    BSTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->right))
    {
        x = y;
        y = y->parent;
    }
 
    return y;
}
 
/*
 * 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
 */
template <class T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T> *x)
{
    // 如果x存在左孩子，则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
    if (x->left != NULL)
        return maximum(x->left);
 
    // 如果x没有左孩子。则x有以下两种可能：
    // (01) x是"一个右孩子"，则"x的前驱结点"为 "它的父结点"。
    // (01) x是"一个左孩子"，则查找"x的最低的父结点，并且该父结点要具有右孩子"，找到的这个"最低的父结点"就是"x的前驱结点"。
    BSTNode<T>* y = x->parent;
    while ((y!=NULL) && (x==y->left))
    {
        x = y;
        y = y->parent;
    }
 
    return y;
}
 
/*
 * 将结点插入到二叉树中
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 插入的结点
 */
template <class T>
void BSTree<T>::insert(BSTNode<T>* &tree, BSTNode<T>* z)
{
    BSTNode<T> *y = NULL;
    BSTNode<T> *x = tree;
 
    // 查找z的插入位置
    while (x != NULL)
    {
        y = x;
        if (z->key < x->key)
            x = x->left;
        else
            x = x->right;
    }
 
    z->parent = y;
    if (y==NULL)
        tree = z;
    else if (z->key < y->key)
        y->left = z;
    else
        y->right = z;
}
 
/*
 * 将结点(key为节点键值)插入到二叉树中
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     key 插入结点的键值
 */
template <class T>
void BSTree<T>::insert(T key)
{
    BSTNode<T> *z=NULL;
 
    // 如果新建结点失败，则返回。
    if ((z=new BSTNode<T>(key,NULL,NULL,NULL)) == NULL)
        return ;
 
    insert(mRoot, z);
}
 
/*
 * 删除结点(z)，并返回被删除的结点
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 删除的结点
 */
template <class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T>* &tree, BSTNode<T> *z)
{
    BSTNode<T> *x=NULL;
    BSTNode<T> *y=NULL;
 
    if ((z->left == NULL) || (z->right == NULL) )
        y = z;
    else
        y = successor(z);
 
    if (y->left != NULL)
        x = y->left;
    else
        x = y->right;
 
    if (x != NULL)
        x->parent = y->parent;
 
    if (y->parent == NULL)
        tree = x;
    else if (y == y->parent->left)
        y->parent->left = x;
    else
        y->parent->right = x;
 
    if (y != z)
        z->key = y->key;
 
    return y;
}
 
/*
 * 删除结点(z)，并返回被删除的结点
 *
 * 参数说明：
 *     tree 二叉树的根结点
 *     z 删除的结点
 */
template <class T>
void BSTree<T>::remove(T key)
{
    BSTNode<T> *z, *node;
 
    if ((z = search(mRoot, key)) != NULL)
        if ( (node = remove(mRoot, z)) != NULL)
            delete node;
}
 
/*
 * 销毁二叉树
 */
template <class T>
void BSTree<T>::destroy(BSTNode<T>* &tree)
{
    if (tree==NULL)
        return ;
 
    if (tree->left != NULL)
        return destroy(tree->left);
    if (tree->right != NULL)
        return destroy(tree->right);
 
    delete tree;
    tree=NULL;
}
 
template <class T>
void BSTree<T>::destroy()
{
    destroy(mRoot);
}
 
/*
 * 打印"二叉查找树"
 *
 * key        -- 节点的键值
 * direction  --  0，表示该节点是根节点;
 *               -1，表示该节点是它的父结点的左孩子;
 *                1，表示该节点是它的父结点的右孩子。
 */
template <class T>
void BSTree<T>::print(BSTNode<T>* tree, T key, int direction)
{
    if(tree != NULL)
    {
        if(direction==0)    // tree是根节点
            cout << setw(2) << tree->key << " is root" << endl;
        else                // tree是分支节点
            cout << setw(2) << tree->key << " is " << setw(2) << key << "'s "  << setw(12) << (direction==1?"right child" : "left child") << endl;
 
        print(tree->left, tree->key, -1);
        print(tree->right,tree->key,  1);
    }
}
 
template <class T>
void BSTree<T>::print()
{
    if (mRoot != NULL)
        print(mRoot, mRoot->key, 0);
}
 
#endif

二叉查找树的C++测试程序(BSTreeTest.cpp)

/**
 * C++ 语言: 二叉查找树
 *
 * @author skywang
 * @date 2013/11/07
 */
 
#include <iostream>
#include "BSTree.h"
using namespace std;
 
static int arr[]= {1,5,4,3,2,6};
#define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) )
 
int main()
{
    int i, ilen;
    BSTree<int>* tree=new BSTree<int>();
 
    cout << "== 依次添加: ";
    ilen = TBL_SIZE(arr);
    for(i=0; i<ilen; i++)
    {
        cout << arr[i] <<" ";
        tree->insert(arr[i]);
    }
 
    cout << "\n== 前序遍历: ";
    tree->preOrder();
 
    cout << "\n== 中序遍历: ";
    tree->inOrder();
 
    cout << "\n== 后序遍历: ";
    tree->postOrder();
    cout << endl;
 
    cout << "== 最小值: " << tree->minimum() << endl;
    cout << "== 最大值: " << tree->maximum() << endl;
    cout << "== 树的详细信息: " << endl;
    tree->print();
 
    cout << "\n== 删除根节点: " << arr[3];
    tree->remove(arr[3]);
 
    cout << "\n== 中序遍历: ";
    tree->inOrder();
    cout << endl;
 
    // 销毁二叉树
    tree->destroy();
 
    return 0;
}

关于二叉查找树的C++实现有两点需要补充说明的:
第1点：采用了STL模板。因此，二叉查找树支持任意数据类型。
第2点：将二叉查找树的"声明"和"实现"都位于BSTree.h中。这是因为，在二叉查找树的实现采用了模板；而C++编译器不支持对模板的分离式编译！

二叉查找树的C++测试程序

yuanmartin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树——C++
Ll_R_lL的博客
10-31 433
比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种。再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是就构成一种键值对。情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除。2.统计水果出现的次数——计数器只适用于整型。
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1376
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
二叉排序树——课后练
小蒋的博客
11-05 965
二叉排序树——课后练
C/C++数据结构（十）—— 二叉查找树
热门推荐
Edison's 小宇宙
01-13 2万+
二叉查找树（Binary Search Tree），也称二叉排序树或二叉搜索树。
C++二叉搜索树——插入
qq_43640822的博客
05-31 488
​ 通过结构体作为节点，结构体包含四个成员，分别是键值key，指向父节点的指针 *parent，指向左子节点的指针 *left，指向右子节点的指针 *right。 struct Node{ int key; Node *left,right,parent; } ​ 从根以起点寻找节点 x 的插入位置。 设当前节点为 x，如果 z 的键值小于 x 则将当前节点的左子节点作为下一个 x，反之则以...
分门别类刷leetcode——二叉查找树（C++实现）
一直走，不要回头
01-27 869
二叉查找树   基本概念   二叉查找树插入节点 将某节点 (insert_node)，插入至以node为根的二叉查找树中： 1、如果 insert_node 节点值小于当前node节点值： 如果node有左子树，则递归的将该节点插入至左子树为根的二叉查找树中 否则，将node-&gt;left赋值为该节点的地址 2、大于等于时 如果node有右子树，则递归的将该节点插入至右...
C++——二叉搜索树
weixin_49449676的博客
11-30 1916
若要删除8，这里采用右树最左节点的替换法，右树的最左节点就是10自己，如果这样写会有错误，while循环都不会进去，minparent就是空，而后面minParent->_left = min->_right;用左子树的最大节1点或右子树的最小节点4，若采用右树的最小节点，交换3和4删除4之后，删除3，但还有一个子节点5，我们让5成为6的左节点。若果要删除跟节点，而且左为空，若要删除8，我们更新根节点即可，让根节点指向10。若果要删除跟节点，而且右为空，若要删除8，让根节点指向3即可。
C++ 二叉查找树 —— 插入、遍历、查找、删除、销毁
辛旭东小小工作室
03-15 2447
二叉查找树的特性： 二叉查找树（Binary Search Tree）（又：二叉搜索树，二叉排序树） 具有以下特性： （1）若“左子树”不为空，则“左子树”上所有节点的值均小于“根节点”的值； （2）若“右子树”不为空，则“右子树”上所有节点的值均大于“根节点”的值； （3）左、右子树也分别为二叉排序树。 01 声明： #include &lt;iostream&gt; us...
C++数据结构——二叉搜索树（详细图解，详细代码实现）
最新发布
Zfox的博客
07-18 902
详细讲解了C++数据结构的二叉搜索树的实现
二叉查找树 减治法——C++代码
05-24
以下是C++实现二叉查找树的基本框架： ```cpp struct TreeNode { int key; int value; TreeNode* left; TreeNode* right; TreeNode(int k, int v) : key(k), value(v), left(nullptr), right(nullptr) {} }; ...
二叉查找树
01-20
在实际编程中，二叉查找树可以通过类似以下C++代码来实现，使用结构体表示每个节点，并定义插入、查找前驱和后继的函数。 ```cpp typedef struct BinarySearchTree{ int val; int rank; int size; int cnt; ...
数据结构——二叉查找树（BST）静态查找表.zip
09-18
总结，"数据结构——二叉查找树（BST）静态查找表"的主题涵盖了如何使用数据结构实现BST，以及在静态查找表环境下BST的插入、删除、查找、遍历等操作及其效率。通过学习这部分内容，我们可以深入理解BST的原理，并能...
课程设计——二叉查找树
03-13
在这个“课程设计——二叉查找树”项目中，开发者创建了一个桌面应用程序，用于实现对二叉查找树的操作。用户可以通过界面进行交互，进行查找操作，同时能够直观地观察到操作的结果。这对于学习和理解二叉查找树的...
《数据结构——C++实现》（第二版）课本源代码
10-30
《数据结构——C++实现》（第二版）是一本经典的计算机科学教材，专注于介绍各种数据结构及其在C++编程语言中的实现。这本书的核心是通过实际的代码示例帮助读者理解和掌握数据结构的基本概念，这对于任何想要深入...
集合——并查集的C++实现及优化
yuanmartin的博客
09-09 9175
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 并查集的C++实现及优化前言一、什么是并查集（Disjoint-set）三、C++实现一方法一：方法二：五、C++实现二（优化版）总结 前言 提并查集（Disjoint-set） 的代码非常简洁，但是功能却很强大。 关于并查集，这里有一篇文章超有爱的并查集~，讲得非常好，但是只使用了并查集两个主要优化中的"路径压缩"优化，并且我觉得很多情况下采用递归的写法要比采用循环的写法要易懂很多。本文将使用C++实现并查集并使用“按秩合并”和”路径压
平衡搜索树——B+树的c++实现
yuanmartin的博客
09-10 1761
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录B+树简介B+树结构代码实现1.BPulsTree.hBPulsTree.cppDemo.cpp B+树简介 B+ 树是一种树数据结构，通常用于数据库和操作系统的文件系统中。B+ 树的特点是能够保持数据稳定有序，其插入与修改拥有较稳定的对数时间复杂度。B+ 树元素自底向上插入，这与二叉树恰好相反。 B+树结构 B+树有一个重要的参数叫 阶 (m)，决定了一颗B+树每一个节点存储关键子的个数。 每一个节点都会按顺序存储一组关键字，
多叉树——Trie树的c++实现
yuanmartin的博客
09-09 1244
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 Trie树 c++实现Trie树介绍2. Trie树性质3. trie树典型应用：(1)字符串检索(2) 词频统计(3) 去除重复单词(4) 字符串排序(5) 最长公共前缀(6) 前缀匹配:4. Trie树设计5. Trie树优点：6. Trie树操作7. 实现8. 其他代码实现9. 参考： Trie树介绍 Trie，又称单词查找树、前缀树，是一种多叉树结构。如下图所示： 上图是一棵Trie树，表示了关键字集合{“a”, “to”, “t
搜索树——c++实现
yuanmartin的博客
09-10 780
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录搜索树索引二叉搜索树：二叉搜索树的操作：1. 搜索：2. 插入3. 删除二叉搜索树的实现 搜索树 搜索树适用于字典描述，与跳表和散列相比，二叉搜索树和平衡搜索树使用更加灵活，在最坏的情况下性能有保证。 二叉搜索树： 是一棵二叉树，可能为空，非空的二叉搜索树满足以下特征： 1.每个元素都有唯一的关键字 2.根节点的左子树中，元素的关键字都小于根节点的关键字 3.根节点的右子树中，元素的关键字都大于根节点的关键字 4.根节点左右子树也
C++最佳实践：二叉搜索树详解
"C++最佳实践——二叉搜索树" 在C++编程中，遵循最佳实践是提高代码质量、可读性和效率的关键。二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树，其每个节点都具有BST属性：对于任意两个节点x和y，如果y...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值