二叉查找树

最新推荐文章于 2022-05-23 22:35:02 发布
翻译 最新推荐文章于 2022-05-23 22:35:02 发布 · 391 阅读 · 0

二叉查找树是一种有限制规则的二叉树，规定二叉树中所有节点的右子树中的所有项都大于节点的项，左子树中的所有项都小于节点中的项。

所以二叉查找树有利于对数据项进行查找。

二叉查找树中主要涉及的操作有：遍历，查找(查找值为key的节点、查找最小，最大节点、查找比当前节点大的最小节点、查找比当前节点小的最大节点)、插入、删除、销毁、打印）

完整的二叉查找树代码

#ifndef BSTREE_H
#define BSTREE_H
#include<iostream>
#include<iomanip>
using namespace std;
template <typename T>
class BSTNode
{
public:
    T key;
    BSTNode *left;
    BSTNode *right;
    BSTNode *parent;
    BSTNode(T value,BSTNode *p,BSTNode *l,BSTNode *r):key(value)
      ,parent(p),left(l),right(r){}
};
template <typename 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();
    //查找二叉树中数据值大于该节点的最小节点
    BSTNode<T>* successor(BSTNode<T> *x);
    //查找二叉树中数据值小于该节点的最大节点
    BSTNode<T>* predecessor(BSTNode<T>*x);
    //将节点插入到二叉树中
    void insert(T 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;
    BSTNode<T>* search(BSTNode<T>*x,T key)const;
    BSTNode<T>* iterativeSearch(BSTNode<T>*x,T key)const;
    BSTNode<T>* minimum(BSTNode<T>* tree);
    BSTNode<T>* maximum(BSTNode<T>* tree);
    void insert(BSTNode<T>* &tree,BSTNode<T> *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 <typename T>
BSTree<T>::BSTree():mRoot(nullptr)
{

}
//析构函数
template<typename T>
BSTree<T>::~BSTree()
{
    destroy();
}
template<class T>
void BSTree<T>::preOrder(BSTNode<T>* tree)const
{
    if(tree!=nullptr)
    {
        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!=nullptr)
    {
        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!=nullptr)
    {
        postOrder(tree->left);
        postOrder(tree->right);
        cout<<tree->key<<"  ";

    }
}
template<class T>
void BSTree<T>::postOrder()
{
    postOrder(mRoot);
}
template<class T>
BSTNode<T>* BSTree<T>::search(BSTNode<T> *x, T key) const
{
    if(x==nullptr||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);
}
template<class T>
BSTNode<T>* BSTree<T>::iterativeSearch(BSTNode<T> *x, T key) const
{
    while((x!=nullptr)&&(x->key!=key))
    {
        if(key<x->key)
            x=x->left;
        else
            x=x->right;
    }
}
template<class T>
BSTNode<T>* BSTree<T>::minimum(BSTNode<T>*tree)
{
    if(tree==nullptr)
        return nullptr;
    while(tree->left!=nullptr)
    {
        tree=tree->left;
    }
    return tree;
}
template<class T>
T BSTree<T>::minimum()
{
    BSTNode<T>* p=minimum(mRoot);
    if(p!=nullptr)
    {
        return p->key;
    }
    return (T)nullptr;
}
template<class T>
BSTNode<T>* BSTree<T>::maximum(BSTNode<T>* tree)
{
    if(tree==nullptr)
        return nullptr;
    while(tree->right!=nullptr)
    {
        tree=tree->right;
    }
    return tree;
}
template<class T>
T BSTree<T>::maximum()
{
    BSTNode<T>* p=maximum(mRoot);
    if(p!=nullptr)
    {
        return p->key;
    }
    return (T)nullptr;

}
template<class T>
BSTNode<T>* BSTree<T>::successor(BSTNode<T> *x)
{
    if(x->right!=nullptr)
        return minimum(x->right);
    BSTNode<T>* y=x->parent;
    while((y!=nullptr)&&(x==y->right))
    {
        x=y;
        y=y->parent;
    }
    return y;
}
template<class T>
BSTNode<T>* BSTree<T>::predecessor(BSTNode<T> *x)
{
    if(x->left!=nullptr)
        return maximum(x->left);
    BSTNode<T>* y=x->parent;
    while((y!=nullptr)&&(x==y->left))
    {
        x=y;
        y=y->parent;
    }
    return y;
}
template<class T>
void BSTree<T>::insert(BSTNode<T> *&tree, BSTNode<T> *z)
{
    BSTNode<T>*y=nullptr;
    BSTNode<T>*x=tree;
    while(x!=nullptr)
    {
        y=x;
        if(z->key<x->key)
            x=x->left;
        else
            x=x->right;

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


}
template<class T>
void BSTree<T>::insert(T key)
{
    BSTNode<T>* z=nullptr;
    if((z=new BSTNode<T>(key,nullptr,nullptr,nullptr))==nullptr)
        return;
    insert(mRoot,z);
}
template<class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T> *&tree, BSTNode<T> *z)
{
    BSTNode<T>*x=nullptr;
    BSTNode<T>*y=nullptr;
    if((z->left==nullptr)||(z->right==nullptr))
        y=z;
    else
        y=successor(z);
    if(y->left!=nullptr)
        x=y->left;
    else
        x=y->right;
    if(x!=nullptr)
        x->parent=y->parent;
    if(y->parent==nullptr)
        tree=x;
    else if(y==y->parent->left)
        y->parent->right=x;
    else
        y->parent->right=x;
    if(y!=z)
        z->key=y->key;
    return y;
}
template<class T>
void BSTree<T>::remove(T key)
{
    BSTNode<T>*z,*node;
    if((z=search(mRoot,key))!=nullptr)
    {
        if((node=remove(mRoot,z))!=nullptr)
            delete node;
    }
}
template<class T>
void BSTree<T>::print(BSTNode<T>* tree,T key,int direction)
{
    if(tree!=nullptr)
    {
        if(direction==0)
            cout<<setw(2)<<tree->key<<"is root"<<endl;
        else
            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!=nullptr)
        print(mRoot,mRoot->key,0);
}
template<class T>
void BSTree<T>::destroy(BSTNode<T>* &tree)
{
    if(tree==nullptr)
        return;
    if(tree->left!=nullptr)
        return destroy(tree->left);
    if(tree->right!=nullptr)
        return destroy(tree->right);
    delete tree;
    tree=nullptr;
}
template<class T>
void BSTree<T>::destroy()
{
    destroy(mRoot);
}

#endif // BSTREE_H

代码解析

三种遍历方法
采用递归方法对树进行遍历

//前序遍历
template<class T>
void BSTree<T>::preOrder(BSTNode<T>*tree)const
{
if(tree!=nullptr)
{
cout<<tree->key<<" ";
preOrder(tree->left);
preOrder(tree->right);
}
//中序遍历
template<class T>
void BSTree<T>::inOrder(BSTNode<T>*tree)const
{
if(tree!=nullptr)
{
inOrder(tree->left);
cout<<tree->key<<" ";
inOrder(tree->right);
}
//后序遍历
template<class T>
void BSTree<T>::postOrder(BSTNode<T>*tree)const
{
if(tree!=nullptr)
{
postOrder(tree->left);
postOrder(tree->right);
cout<<tree->key<<" ";
}

查找

1 查找值为key的节点
先查找根节点，如果小于根节点就查找左子树，如果大于根节点就查找右子树。

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

2 查找二叉树最小节点
二叉树最小节点就是沿着左子树查找的最后的一个节点

template<class T>
BSTNode<T>*BSTree<T>::minimum(BSTNode<T>*tree)
{
if(tree==nullptr)
return nullptr;
while(tree->left!=nullptr)
{
tree=tree->left;
}
return tree;
}

3 查找二叉树最大节点
查找最大节点，查找二叉树右子树的最后一个节点

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

4 查找当前节点的前驱节点
当前节点的前驱节点就是比这个节点的值小的节点，如果这个节点有左子树，就是查找这个节点的左子树的最大节点，如果没有左子树，那么如果这个节点是他的父节点的右节点，那么他的父节点就是他的前驱节点，如果这个节点是父节点的左节点，那么就查找它父节点的父节点。

template<class T>
BSTNode<T>*BSTree<T>::predecessor(BSTNode<T>*x)
{
if(x->left!=nullptr)
return maximum(x->left);
BSTNode<T>*y=x->parent;
while((y!=nullptr)&&(x==y->left))
{
x=y;
y=y->parent;
}
return y;
}

5 查找当前节点的后继节点
如果当前节点有右子树，那么他的后继节点就是右子树的最小值，如果没有右子树，那么如果当前节点是父节点的左子树，那么他的后继节点是他的父节点，如果当前节点是父节点的右子树，那么他的后继节点是直到他的父节点作为父节点的父节点的左子树为止。

template<class T>
BSTNode<T>*BSTree<T>::successor(BSTNode<T>*tree)const
{
if(tree->right!=nullptr)
return minimum(x->right);
BSTNode<T>*y=x->parent;
while((y!=nullptr)&&(x==y->right))
{
x=y;
y=y->parent;
}
return y;
}

6 插入
插入算法就是如果插入的节点的值大于当前节点，那么就插入到右子树中，如果小于当前节点，那么就插入到左子树中。插入可以采用递归算法和非递归算法

//递归算法
template<class T>
void BSTree<T>::insert(BSTNode<T>*&tree,BSTNode<T>*z)
{
if(tree==nullptr)
tree=z;
else if(z->key<tree->key)
insert(tree->left,z)
else if(z->key>tree->key)
insert(tree->right,z);
}
//非递归算法
template<class T>
void BSTree<T>::insert(BSTNode<T>*&tree,BSTNode<T>*z)
{
BSTNode<T>*y=nullptr;
BSTNode<T>*x=tree;
while(x!=nullptr)
{
y=x;
if(z->key<x->key)
x=x->left;
else
x=x->right;
}
if(y==nullptr)
tree=z;
else if(z->key<y->key)
y->left=z;
else
y->right=z;

7 删除
从二叉树中删除一个节点分好几种情况，如果要删除的节点只有一个儿子，那么将节点删除，直接将这个节点的父节点作为儿子节点的父节点。如果节点有两个儿子，那么查找这个节点的后继节点，

template<class T>
BSTNode<T>* BSTree<T>::remove(BSTNode<T>*&tree,BSTNode<T>*z)
{
BSTNode<T>*x=nullptr;
BSTNode<T>*y=nullptr;
if((z->left==nullptr)||(z->right==nullptr))
y=z;
else
y=successor(z);
if(y->left!=nullptr)
x=y->left;
else
x=y->right;
if(x!=nullptr)
x->parent=y->parent;
if(y->parent==nullptr)
tree=x;
else if(y==y->parent->left)
y->parent->right=x;
if(y!=z)
z->key=y->key;
return y;
}

8 打印
打印二叉树相当于遍历，可以采用前序、后序、中序。

//direction等于0表示该节点是跟节点，direction等于-1表示该节点是它父节点的左孩子，direction等于1表示该节点是它父节点的右孩子。
template<class T>
void BSTree<T>::print(BSTNode<T>*tree,T key,int direction）
{
if(tree!=nullptr)
{
if(direction==0)
cout<<tree->key<<"is root"<<endl;
else
cout<<tree->key<<is<<key<<"'s"<<(direction==1?"right child":"left child")<<endl;
print(tree->left,tree->key,-1);
print(tree->right,tree->key,1);
}

}

9 销毁
采用递归方法

template<class T>
void BSTree<T>::destroy(BSTNode<T>*&tree)
{
if(tree==nullptr)
return;
if(tree->left!=nullptr)
return destroy(tree->left);
if(tree->right!=nullptr)
return destroy(tree->right);
delete tree;
tree=nullptr;
}

二叉查找树的所有节点的平均深度为O(logN)但是二叉查找树在经过不断的插入和删除操作会达到二叉树出现不平衡的状态，为了使树在插入和删除过程中达到平衡状态需要添加平衡条件，AVL树就是一种经典的平衡查找树。还有一种方法是通过自调整使树达到和平衡一样的效果，这种数据结构叫做伸展树。

数据结构_查找二叉树中值为key的节点，并将指针指向该节点_C语言源代码
u013227200的专栏
07-20 2741
void PreSearch(BTNode *T, BTNode *&p,char key)//x先序方式查找二叉树中，值为key的节点，并将指针p指向该节点  {     if(NULL != T)      {          if(T->data == key)          {            p=T;            return ;          
2021-10-11 二叉树中查找值为key的结点
SuSA_的博客
10-11 1007
主要提醒自己这里的return，还是遍历框架的应用 两个使用框架的题的比较 //! 二叉树的翻转：本质就是二叉树的遍历的应用 //! 以任意形式遍历二叉树的每一个结点，访问每一个结点的同时调换其左右子树 //! 中序遍历额外注意一下调换后的参数问题 Node *BinarySearchTreesZH::invertTreePreOrder(Node *node) { if (node == nullptr) { return node; } Node *tmp
二叉树查找结点值
weixin_44502835的博客
08-20 1810
在二叉树中查找data域等于key的值是否存在，若存在用q指向它； #include <iostream> #include<cstdio> #include<cstdlib> using namespace std; typedef struct BTnode{ int data; struct BTnode *lchild; ...
搜索二叉树-key模型
h1091068389的博客
05-23 345
搜索二叉树搜索二叉树概念实现搜索二叉树构成插入中序遍历查找删除 搜索二叉树概念 搜索二叉树作为一种树型结构，他和普通二叉树有如下几种区别： 搜索二叉树的左子树，如果不为空的情况下，左子树上面所有节点的值都小于根节点 搜索二叉树的右子树，如果不为空的情况下，右子树上面所有节点的值都大于根节点 这个性质可以适用于该搜索二叉树的任意节点。 这样看来对于一个搜索二叉树的中序遍历，即可实现从小到大遍历该二叉树中的所有节点 实现搜索二叉树 构成 搜索二叉树节点的结构体和正常二叉树相同，都是由左右节点指针和其中存放的ke
查找data域为key的结点
Phil_Collin的博客
03-08 745
题目 在一棵以二叉链表为存储结构的二叉树中，查找data域值等于key的结点是否存在（找到任何一个满足要求的结点即可），如果存在，则将q指向该结点，否则q赋值为NULL，假设data域为int型 函数代码 //寻找data域等于key的结点，并用q指向它，若不存在，则q指向NULL void search(BTNode *p, BTNode *&q, int key)//注意，这里的q参数定义为引用型指针，因为q要改变 { if(p!=NULL) { if(p->data==key
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉查找树python二叉查找树源码
11-22
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构。它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉查找树中，对于...
最优二叉查找树 动态规划法.cpp.rar
10-14
最优二叉查找树（Optimal Binary Search Tree, OBST）是一种高效的检索数据结构，它根据键值分布的不同，自适应地调整树的形态以达到最小化查找时间的目的。在计算机科学中，动态规划（Dynamic Programming, DP）是...
JS实现二叉查找树的建立以及一些遍历方法实现
10-20
在计算机科学中，二叉查找树（BST）是一种特殊的二叉树结构，它满足所有节点的左子树都小于该节点，所有节点的右子树都大于该节点。这种特性使得二叉查找树在查找、插入和删除元素时可以提供很高的效率。本文将详细...
数据结构-BST树(镜像&前序&中序&后序&重构)
Fly_Fly_Zhang的博客
07-04 574
package com.AdvancedDataStructure.BSTTree; import java.util.LinkedList; import java.util.Stack; /** * @Created with IntelliJ IDEA * @Description: BST树代码演示 * @Package: com.AdvancedDataStructure.B...
查找二叉树的节点（某一值的节点）
luobo140716的专栏
01-01 1506
#include <iostream> #include <stdio.h> #include <stdlib.h> struct BinaryTreeNode{ char value; struct BinaryTreeNode *lchild, *rchild; }; // 输入值依次是：a、b、#、#、c、#、# struct Bin...
BST（二叉排序树）
foooooods的博客
01-25 1372
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 查询二叉搜索树： 递归的： tree_search(x,k) if(x==NULL |...
二叉查找树（BST）
不很正派的专栏
01-13 942
什么是二叉查找树 二叉查找树（Binary Search Tree）又叫二叉排序树（Binary Sort Tree），它是一种数据结构，支持多种动态集合操作，如 Search、Insert、Delete、Minimum 和 Maximum 等。 二叉查找树要么是一棵空树，要么是一棵具有如下性质的非空二叉树： 若左子树非空，则左子树上的所有结点的关键字值均小于根结点的关键字值。 若右子树非
二叉排序树(BST)构造与应用
热门推荐
火雨(Nick)
03-20 2万+
二叉排序树(BST)构造与应用           二叉排序树(BST)：又称二叉查找树，其定义为：二叉排序树或者是空树，或者是满足以下性质的二叉树。        (1) 若它的左子树非空，则左子树上所有记录的关键字均小于根记录的值。        (2) 若它的右子树非空，则右子树上所有记录的关键字均大于根记录的值。        (3) 左、右子树本身又各是一棵二叉排序树。
每日一数据结构封装之二叉搜索树
sydney__的博客
01-01 190
#include <iostream> using namespace std; template <typename T> struct BSTNode { T val; BSTNode<T>* lchild; BSTNode<T>* rchild; BSTNode<T>* parent; ...
BST树基本操作
weixin_43391348的博客
06-04 473
文章目录BST树的概念BST树的实现BST树的插入操作BST树的删除操作BST树的查找BST树的遍历BST树的前序遍历BST树的中序遍历BST树的后序遍历BST树的层序遍历BST树的一些常见题型 BST树的概念 一、二叉搜索树（binary search tree）即就是我们所说的BST树 二、BST树的特征：任何一个节点比它的左孩子大，比它的右孩子小， 如图所示就是一颗BST树 三、定义BST...
基于SSM与Vue架构的病人跟踪治疗信息管理系统设计与实现（含源码及文档）
最新发布
12-22
基于SSM架构与Vue技术构建的病人治疗追踪管理系统，采用Java编程语言实现业务逻辑，并以MySQL数据库作为数据存储支持。该系统主要包含三个用户角色：管理员、病人及普通访客。 管理员具备的功能模块包括：主界面、个人设置、病人档案管理、病例信息采集、预约安排、医生信息维护、核酸检测报告上传管理、行动轨迹记录管理、疾病分类配置、病人治疗进度跟踪、留言板处理以及系统参数管理。病人用户可操作：主界面、个人设置、病例信息查看、预约申请、医生查询、核酸检测报告上传、行动轨迹上报、个人治疗状态查询。访客端提供：首页浏览、医生信息展示、医疗资讯发布、留言反馈提交、个人中心、后台入口及在线咨询服务。 系统设计注重代码结构的清晰性与可维护性，强调功能实用性和界面简洁度，同时保持较强的扩展适应能力，便于后续功能升级与日常运维。 项目已通过实际运行测试，开发环境配置如下： - 编程语言：Java - 开发框架：Spring Boot - Java开发工具包：JDK 1.8 - 应用服务器：Tomcat 7 - 数据库系统：MySQL 5.7 - 数据库管理工具：Navicat 12 - 集成开发环境：Eclipse或IntelliJ IDEA - 项目构建工具：Maven 3.3.9。 资源来源于网络分享，仅用于学习交流使用，请勿用于商业，如有侵权请联系我删除！
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值