二叉查找树的实现

最新推荐文章于 2019-09-26 16:53:33 发布
最新推荐文章于 2019-09-26 16:53:33 发布
阅读量464 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010167037/article/details/22324213
版权

初学者实现了二叉查找树的实现：

实现的功能包括：

  1. 构造函数
  2. 西沟函数
  3. 判空函数
  4. 递归搜素
  5. 非递归搜索
  6. 删除元素
  7. 前序遍历
  8. 中序遍历
  9. 后续遍历
  10. 层遍历 ---没有实现
直接上代码吧，请大牛指导

头文件：

BST.h

#include<iostream>
using namespace std;
#ifndef BST
#define BST

template <class T>
class bst{

private:
    struct Node{
        T data;
        Node *lc;
        Node *rc;
        Node():lc(0),rc(0){};
        Node(T item):data(item),lc(0),rc(0){};
    };
    Node *myroot;
    //赋值函数
    void BST_copy(Node**,Node*);
    void inorderAux(ostream&,Node*) const;
    void PostorderAux(ostream&,Node*) const;
    void preorderAux(ostream&,Node*) const;
    bool searchaux(Node*,T ) const;
    void insertaux(Node**,T);

public:
    bst();//初始化为一颗空树
    bst(const bst<T> &);
    ~bst();

    bst<T>& operator=(const bst<T>&);
    bool empty() const;

    bool search1(const T)const;//采用递归
    bool search2(const T)const;//采用非递归

    void insert1(T);//采用递归
    void insert2(T);//采用非递归

    bool remove(T);//分删除叶子节点和单个孩子节点 以及两个孩子的节点

    void PreOrder(ostream &)const;
    void InOrder(ostream &) const;
    void PostOrder(ostream &)const;
    void LayerOrder(ostream &)const;

    void graph();
};
#endif // BST


类的成员函数实现文件：

BST.cpp

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

//实现BST的成员函数


//初始化
template<class T>
bst<T>::bst():myroot(0){};


//赋值函数--已经实现
template<class T>
bst<T>::bst(const bst<T>& BST_original){
    if(!BST_original.empty()){

        bst<T>::Node* original=BST_original.myroot;
        BST_copy(&(myroot),original);
    }
}

template<class T>
void bst<T>::BST_copy(bst<T>::Node **target,bst<T>::Node* orginal){

    if(orginal!=0){
        *target=new bst<T>::Node(orginal->data);
        if(orginal->lc!=0)
            BST_copy(&((*target)->lc),orginal->lc);
        if(orginal->rc!=0)
            BST_copy(&((*target)->rc),orginal->rc);
    }
}


//析构函数 -----没有实现
template<class T>
bst<T>::~ bst(){

}

//赋值操作符 --已经实现
template<class T>
bst<T>& bst<T>::operator=(const bst<T>& BST_original){
    if(!BST_original.empty()){
        bst<T>::Node* original=BST_original.myroot;
        BST_copy(&(myroot),original);
    }
    return *this;
}



//判空操作--已经实现
template<class T>
bool bst<T>::empty() const{
    return 0==myroot;
}



//递归搜索---已经实现
template<class T>
bool  bst<T>::search1(const T item) const{
    if(empty())
        return false;
    else
        return searchaux(myroot,item);
}

template<class T>
bool  bst<T>::searchaux(bst<T>::Node* subroot,const T item) const{
    if(subroot==0)
        return false;//已经是空树了  没有找到
    if(item>subroot->data)
        return searchaux(subroot->rc,item);
    else if(item<subroot->data)
        return searchaux(subroot->lc,item);
        else
            return true;
}


//非递归搜索-已经实现
template<class T>
bool  bst<T>::search2(const T item)const{
    bool found=false;
    bst<T>::Node* ptmp=myroot;
    while(ptmp&&!found){
        if(item<ptmp->data)
            ptmp=ptmp->lc;
        else if(item>ptmp->data)
            ptmp=ptmp->rc;
        else
            found=true;
    }
    return found;
}

//采用递归
template<class T>
void  bst<T>::insert1(T item){
     insertaux(&myroot,item);
}

//递归插入实现函数
template<class T>
void bst<T>::insertaux(bst<T>::Node **subroot, T item){
    if(*subroot==0){
        *subroot=new bst<T>::Node(item);
    }
    else if(item>(*subroot)->data)
        insertaux(&((*subroot)->rc),item);
    else if(item<(*subroot)->data)
       insertaux(&((*subroot)->lc),item);
    else
        cout<<"The data has already in the BST~~~"<<endl;
}


//非递归插入---已经实现
template<class T>
void  bst<T>::insert2(T item){
    if(empty()){
        cout<<"empty bst,creat it~~`"<<endl;
        myroot=new bst<T>::Node(item);
    }else{
      bst<T>::Node *parent=0;
      bst<T>::Node *ptemp=myroot;
      bool found=false;
      while(!found&&ptemp!=0){
            parent=ptemp;
            if(item<ptemp->data)
                ptemp=ptemp->lc;
                else if(item>ptemp->data)
                  ptemp=ptemp->rc;
                else
                found=true;
            }
        if(!found){
            if(item>parent->data)
                parent->rc=new bst<T>::Node(item);
            else if(item<parent->data)
                parent->lc=new bst<T>::Node(item);
            }
        else{
            cout<<"The data has existed:->"<<item<<endl;
        }
      }
}


//remove
template<class T>
bool bst<T>::remove(T item){
    //首先需要确定这个值在不在树里面，然后确定这个节点有几个还在
    //有一个孩子的情况下或者没有孩子的情况下，直接处理，
    //要是有两个孩子需要处理后续连接的问题
    if(empty())
    {
        cout<<"Empty BST, can not delete the item:->"<<item<<endl;
    }
    else
    {
        bst<T>::Node *ptemp=myroot;
        bst<T>::Node *parent=0;
        bool found=false;
        while(ptemp&&!found){
            if(item<ptemp->data){
               parent=ptemp;
               ptemp=ptemp->lc;}
            else if (item>ptemp->data)
                {parent=ptemp;
                 ptemp=ptemp->rc;}
            else
               found=!found;
        }
        if(!found){
            cout<<"There is no item:->"<<item<<"in this BST"<<endl;
            return 0;
        }
        else{
            bst<T>::Node *pt;
            if(ptemp->lc==0&&ptemp->rc==0)//叶子节点
                {
                    if(ptemp==parent->lc) parent->lc=0;
                    else parent->rc=0;
                    delete ptemp;
                }
            else if(ptemp->lc==0 && ptemp->rc!=0){
                   if(ptemp==parent->lc) parent->lc=ptemp->rc;
                    else parent->rc=ptemp->rc;
                    delete ptemp;}
            else if(ptemp->rc==0 && ptemp->lc!=0){
                    if(ptemp==parent->lc) parent->lc=ptemp->lc;
                    else parent->rc=ptemp->lc;
                    delete ptemp;}
            else{
                //含有左右孩子
                bst<T>::Node *pt2=ptemp;
                bst<T>::Node *parent2=ptemp;
                while(pt2->lc!=0){
                    parent2=pt2;
                    pt2=pt2->lc;
                   }
                ptemp->data=pt2->data;
                if(pt2->rc!=0){
                   parent2->lc= pt2->rc;
                }else{
                    parent2->lc=0;
                     }
                    delete pt2;
            }
        }
    }
}

//先序遍历---已经实现
template<class T>
void bst<T>::PreOrder(ostream &out) const{
    cout<<"先序遍历："<<endl;
    preorderAux(out,myroot);
}

template<class T>
void bst<T>::preorderAux(ostream& out,bst<T>::Node* p) const{
    if(p!=0){
       cout<< p->data<<" ";
       preorderAux(out,p->lc);
       preorderAux(out,p->rc);
    }
}

//中序序遍历--已经实现
template<class T>
void bst<T>::InOrder(ostream &out) const
{
    cout<<"中序遍历："<<endl;
    inorderAux(out,myroot);
}

template<class T>
void bst<T>::inorderAux(ostream& out,bst<T>::Node* p) const{
    if(p!=0){
        inorderAux(out,p->lc);
       cout<< p->data<<" ";
       inorderAux(out,p->rc);
    }
}

//后序遍历---已经实现
template<class T>
void bst<T>::PostOrder(ostream &out) const
{
    cout<<"后序遍历："<<endl;
    PostorderAux(out,myroot);
}

template<class T>
void bst<T>::PostorderAux(ostream& out,bst<T>::Node* p) const{
    if(p!=0){
        PostorderAux(out,p->lc);
        PostorderAux(out,p->rc);
        cout<< p->data<<" ";
    }
}
template<class T>
void bst<T>::LayerOrder(ostream &)const{
}

template<class T>
void bst<T>::graph(){

}




测试文件：
#include <iostream>
#include<fstream>
#include"BST.cpp"
using namespace std;

int main()
{
    ifstream file_stream("BST_in.txt");
    ofstream ft_stream("BST_out.txt");
    int i;
    bst<int> intBST;
    while(file_stream>>i)
        intBST.insert2(i);
   // intBST.InOrder(cout);
    //intBST.PostOrder(cout);
    intBST.PreOrder(cout);

    bst<int> intBST2(intBST);
    //intBST2.InOrder(cout);
    //intBST2.PostOrder(cout);
   // intBST2.PreOrder(cout);

    bst<int> intBST3;
    intBST3=intBST;
    //intBST3.InOrder(cout);
   // bool t1=intBST3.search1(12);
    //cout<<t1<<endl;
    //bool t2=intBST3.search2(100);
   // cout<<t2<<endl;
    //intBST.insert1(1000);
    //intBST.InOrder(cout);
    intBST.remove(6);
    intBST.PreOrder(cout);
    cin>>i;
    return 0;
}


1.在编程中发现如下问题：

1.将一个空的指针传递给函数的时候，将不能实现改变指针所指的值 ，这个表现在insert函数上

2.头文件名为BST  然后将类的名字命名为BST的时候将出现错误，认为没有提供类的名称。

3.将输入写成文件流的形式将更好维护

4const函数只能调用返回const值的成员函数

5，文件流最好不能设置成const类型

有两个成员函数没有实现：层遍历()  和图形化输出函数  以及析构函数----折个 以后再加吧



jamesheros
关注
专栏目录
二叉查找树java实现
飞半天的鱼儿的博客
12-12 162
一、定义 如果一个普通的二叉树每个节点满足：左子树所有节点小于它的根节点值，且右子树所有节点值大于它的根节点值，则这样的二叉树就是排序二叉树。 二 、插入操作 首先要从根节点往下找到自己要插入的位置(即新节点的父节点)；具体流程是：新节点与当前节点比较，如果相同则表示已经存在且不能在重复插入；如果小于当前节点，则到左子树中寻找，如果左子树为空，则当前节点为要找的父节点，新节点插入到当前节点的...
类模板实现二叉查找树
简约而不简单
12-02 804
 二叉查找树是一种特殊的二叉树，这种树上不存在重复的结点，而且它上面的左子树都比其父结点小，它上面的右子树都比其父结点大。值得注意的是：具有相同数据的二叉查找树会随着数据插入顺序不同而不同。在treeNode.h中#ifndef TREENODE_H #define TREENODE_H template typename NodeType> class tree;temp
BST（二叉搜索/排序树）类模板的实现
乐行僧的博客
11-04 5372
BST树的递归定义： (1)BST树是一棵空树。 (2)BST树由根节点、左子树和右子树。左子树和右子树分别都是一棵BST树。 由于二叉树的递归定义，使得在二叉树中许多操作中可以以递归的方式书写操作，代码更加浅显易懂。 重点条件：左子树中的所有节点的数据域都小于或等于根节点的数据域，而右子树中的所有节点的数据域都大于等于根节点的数据域。根据这个特点，BST树的中序遍历是一个由小到大的顺序序列。 B...
二叉查找树的基本实现
Lucky_Go的博客
09-26 546
定义 数组和链表 数组和链表是两种使用频率非常高的数据结构，但两者的结构也决定了他们的应用场景。数组的元素在内存中的地址是连续的，而构成链表的结点在内存中的地址不连续，数组的元素可以通过索引进行随机访问，链表则需要遍历访问，因此数组的查询速度比链表快；另一方面链表的长度可变，插入和删除元素的效率非常高，因此在增删操作较多的情况下链表性能比数组好。 二叉查找树 二叉查找树(Binary Se...
Java基于二叉查找树实现排序功能示例
08-29
Java基于二叉查找树实现排序功能示例 本文主要介绍了Java基于二叉查找树实现排序功能的示例，通过实例形式分析了Java二叉查找树的定义、遍历及排序等相关操作技巧。下面将对这些知识点进行详细的解释和分析。 一、...
C++二叉查找树实现过程详解
12-22
什么是二叉查找树 　在数据结构中，有一个奇葩的东西，说它奇葩，那是因为它重要... 　以下是对于二叉查找树的基本操作定义类，然后慢慢分析是如何实现它们的。 　template 　class BinarySearchTree 　{ 　public
二叉查找树实现简单的信息检索
11-08
在"二叉查找树实现简单的信息检索"中，我们关注的是如何利用二叉查找树来高效地检索信息。首先，我们需要创建一个二叉查找树的数据结构。在提供的文件中，`Binary_tree.h`和`Binary_tree.cpp`很可能是定义和实现这个...
《数据结构与算法》-李春葆 实验报告-典型查找算法实践-二叉查找树实现查找
12-20
这篇实验报告是关于《数据结构与算法》课程中的一次实验，主要关注的是二叉查找树（Binary Search Tree，简称BST）的实现及其在查找操作中的应用。二叉查找树是一种特殊的二叉树，它的每个节点都包含一个键值，且...
二叉查找树 减治法——C++代码
05-24
在C++中实现二叉查找树，一般会定义一个结构体或类来表示树节点，包括键、值和子节点指针。然后，提供一系列成员函数来执行基本操作，如`insert`（插入）、`search`（查找）、`delete`（删除）。以下是C++实现二叉...
C++ 中在函数的前面加上static的作用
u010167037的专栏
04-05 1977
在一般的函数前面加上static,作用是：
各种函数声明和定义模块
最新发布
09-16
各种函数声明和定义模块
湖北工业大学在河南2021-2024各专业最低录取分数及位次表.pdf
09-16
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
1805.06605v2 DEFENSE-GAN.pdf
09-16
1805.06605v2 DEFENSE-GAN.pdf
【语音去噪】FIR和IIR低通+带通+高通语音信号滤波（含时域频域分析）【含Matlab源码 4943期】.mp4
09-16
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 语音处理系列程序定制或科研合作方向：语音隐藏、语音压缩、语音识别、语音去噪、语音评价、语音加密、语音合成、语音分析、语音分离、语音处理、语音编码、音乐检索、特征提取、声源定位、情感识别、语音采集播放变速等；
java-ssm+jsp幼儿园管理系统实现源码(项目源码-说明文档)
09-16
管理员成功登录后台管理界面，选择“教师管理”，出现教师列表。在教师管理页面，管理员可以添加、修改、查询及删除教师信息。 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：ssm 前端技术：jsp 关键技术：jsp、spring、ssm、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
hadoop_3_2_0-yarn-resourcemanager-3.3.4-1.el7.x86_64.rpm
09-16
Ambari+Bigtop 一站式编译和部署解决方案 https://gitee.com/tt-bigdata/ambari-env
DelphiWebMVC-master.zip
09-16
delphi在web系统开发上没有像java或php 这样方便，对于一直使用delphi的工程师来说是个遗憾，因此使用delphi技术开发了一套Web框架，使用MVC模式，让工程师只需把精力放在模型与视图的设计上，让delphi开发web系统更方便。
二叉查找树实现的集合分析与优缺点探讨
"本文主要对二叉查找树进行了总结分析，并介绍了基于二叉查找树实现的集合类的优势和局限性。" 二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构，它的每个节点都包含一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值