《C++实现数据结构》：二叉搜索树

最新推荐文章于 2020-12-08 16:44:33 发布
最新推荐文章于 2020-12-08 16:44:33 发布
阅读量461 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉树 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ancientmoondjay/article/details/64919593
版权

设结点由关键字值表征，假定所有结点的关键字值各不相同，二叉搜索树或者是一棵空二叉树，或者是具有下列性质的二叉树：
（1）若左子树不空，则左子树上所有结点的关键字值均不小于根结点的关键字值。
（2）若右子树不空，则右子树上所有结点的关键字值均大于根结点的关键字值。
（3）左、右子树也分别是二叉搜索树。
具体实现见代码，相关注释已写。

//
// Created by huxijie on 17-3-21.
// 二叉搜索树

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

//二叉树结点类
template <typename T>
struct BTNode{
    T elemet;
    BTNode<T>* lChild,*rChild;

    BTNode() {
        lChild = rChild = NULL;
    }

    BTNode(const T& x) {
        elemet = x;
        lChild = rChild = NULL;
    }

    operator T() const { return elemet; }

    BTNode(const T& x,BTNode<T>* l, BTNode<T> *r) {
        elemet = x;
        lChild = l;
        rChild = r;
    }
};

//二叉搜索树类
template <typename T>
class BSTree{
protected:
    BTNode<T>* root;
private:
    bool Search(BTNode<T> *p,T& x) const;
    void Clear(BTNode<T> *p);
    void PreOrder(void (*Visit)(T &x),BTNode<T> *r);
    void InOrder(void (*Visit)(T &x),BTNode<T> *r);
    void PostOrder(void (*Visit)(T &x),BTNode<T> *r);
    void LayerOrder(void (*Visit)(T &x), BTNode<T> *r);
public:
    BSTree() { root = NULL; }
    ~BSTree();
    bool Search(T x)const;      //搜索是否存在x
    bool Insert(T x);           //插入x
    bool Remove(T x);           //删去x
    void PreOrder(void (*Visit)(T &x));            //先序遍历
    void InOrder(void (*Visit)(T &x));             //中序遍历
    void PostOrder(void (*Visit)(T &x));           //后序遍历
    void LayerOrder(void (*Visit)(T &x));          //层次遍历
};

template <typename T>
BSTree<T>::~BSTree() {
    Clear(root);
}

template <typename T>
void BSTree<T>::Clear(BTNode<T> *p) {
    if (p == NULL) {
        return;
    } else {
        Clear(p->lChild);
        Clear(p->rChild);
        delete (p);
    }
}


//访问元素的函数,作为参数传入遍历函数中
template <typename T>
void Visit(T &x) {
    cout << x << " ";
}

递归实现先序遍历
//template <typename T>
//void BSTree<T>::PreOrder(void (*Visit)(T &x),BTNode<T> *r) {
//    if (r) {
//        Visit(r->elemet);
//        PreOrder(Visit, r->lChild);
//        PreOrder(Visit, r->rChild);
//    }
//}

//非递归实现先序遍历
template <typename T>
void BSTree<T>::PreOrder(void (*Visit)(T &x),BTNode<T> *r) {
    if (r == NULL) {
        return;
    }
    BTNode<T>* p = r;
    stack<BTNode<T> *> mystack;
    while (p != NULL || !mystack.empty()) {
        //边遍历边打印,并存入栈中,以后需要通过这些结点进入右子树
        while (p != NULL) {
            Visit(p->elemet);
            mystack.push(p);
            p = p->lChild;
        }
        //当p为空时,说明根和左子树已经遍历完了,需要进入右子树了
        if (!mystack.empty()) {
            p = mystack.top();
            mystack.pop();
            p = p->rChild;
        }
    }
}

template <typename T>
void BSTree<T>::PreOrder(void (*Visit)(T &)) {
    PreOrder(Visit, root);
}

递归实现中序遍历
//template <typename T>
//void BSTree<T>::InOrder(void (*Visit)(T &), BTNode<T> *r) {
//    if (r) {
//        InOrder(Visit, r->lChild);
//        Visit(r->elemet);
//        InOrder(Visit, r->rChild);
//    }
//}

//非递归实现中序遍历
template <typename T>
void BSTree<T>::InOrder(void (*Visit)(T &), BTNode<T> *r) {
    if (r == NULL) {
        return;
    }
    BTNode<T> *p = r;
    stack<BTNode<T>*> mystack;

    while (p != NULL || !mystack.empty()) {
        //一直遍历到最后一棵左子树,边遍历边保存根结点到栈中
        while (p != NULL) {
            mystack.push(p);
            p = p->lChild;
        }
        //当p为空时,说明已经到达最后一棵左子树了,这时需要出栈了
        if (!mystack.empty()) {
            p = mystack.top();
            mystack.pop();
            Visit(p->elemet);
            //进入右子树,开始新的一轮左子树遍历
            p = p->rChild;
        }
    }
}

template <typename T>
void BSTree<T>::InOrder(void (*Visit)(T &)) {
    InOrder(Visit, root);
}

递归实现后序遍历
//template <typename T>
//void BSTree<T>::PostOrder(void (*Visit)(T &), BTNode<T> *r) {
//    if (r) {
//        PostOrder(Visit, r->lChild);
//        PostOrder(Visit, r->rChild);
//        Visit(r->elemet);
//    }
//}


//非递归实现后序遍历
template <typename T>
void BSTree<T>::PostOrder(void (*Visit)(T &), BTNode<T> *r) {
    if (r == NULL) {
        return;
    }
    stack<BTNode<T>*> mystack;
    BTNode<T>* pCur = r;        //当前访问结点
    BTNode<T>* pLast = NULL;    //上次访问结点

    //一直遍历到最后一棵左子树,边遍历边保存根结点到栈中
    while (pCur != NULL) {
        mystack.push(pCur);
        pCur = pCur->lChild;
    }

    //已经遍历到最后一棵左子树了,接下来从栈中取结点
    while (!mystack.empty()) {
        pCur = mystack.top();
        mystack.pop();
        //一个根结点被访问的前提是：无右子树或者右子树已被访问过
        if (pCur->rChild == NULL || pCur->rChild == pLast) {
            Visit(pCur->elemet);
            //修改最近被访问的结点
            pLast = pCur;
        } else { //先进入右子树
            mystack.push(pCur);     //根结点重新入栈
            pCur = pCur->rChild;    //进入右子树
            while (pCur != NULL) {  //开始在右子树中一直遍历到最后一棵左子树
                mystack.push(pCur);
                pCur = pCur->lChild;
            }
        }
    }
}

template <typename T>
void BSTree<T>::PostOrder(void (*Visit)(T &)) {
    PostOrder(Visit, root);
}

//用队列实现层次遍历
template <typename T>
void BSTree<T>::LayerOrder(void (*Visit)(T &x),BTNode<T> *r) {
    if (!r) {
        return;
    }
    queue<BTNode<T>*> myqueue;
    BTNode<T> *p = r;
    while (p != NULL || !myqueue.empty()) {
        if (p != NULL) {
            Visit(p->elemet);
            myqueue.push(p->lChild);
            myqueue.push(p->rChild);
        }
        p = myqueue.front();
        myqueue.pop();
    }
}

template <typename T>
void BSTree<T>::LayerOrder(void (*Visit)(T &)) {
    LayerOrder(Visit, root);
}

搜索的递归算法
//template <typename T>
//bool BSTree<T>::Search(BTNode<T> *p, T &x) const {
//    if (!p) {
//        return false;
//    } else if (x < p->elemet) {
//        return Search(p->lChild, x);
//    } else if (x > p->elemet) {
//        return Search(p->rChild, x);
//    } else {
//        return true;
//    }
//}

//搜索的迭代算法
template <typename T>
bool BSTree<T>::Search(BTNode<T> *p, T &x) const {
    while (p) {
        if (x < p->elemet) {
            p = p->lChild;
        } else if (x > p->elemet) {
            p = p->rChild;
        } else {
            return true;
        }
    }
    return false;
}

template <typename T>
bool BSTree<T>::Search(T x) const {
    return Search(root, x);
}

template <typename T>
bool BSTree<T>::Insert(T x) {
    BTNode<T> *p = root;
    BTNode<T> *q = NULL;

    while (p) {
        q = p;
        if (x < p->elemet) {
            p = p->lChild;
        } else if (x > p->elemet) {
            p = p->rChild;
        } else {
            cout<<"Duplicate"<<endl;
            return false;
        }
    }

    p = new BTNode<T>(x);
    if (!root) {
        root = p;
    } else if (x < q->elemet) {
        q->lChild = p;
    } else {
        q->rChild = p;
    }   //新结点p连到q结点,成为q的孩子
    return true;
}

template <typename T>
bool BSTree<T>::Remove(T x) {
    BTNode<T> *p = root, *q, *r, *s, *c;
    q = r = s = c = NULL;

    while (p && p->elemet != x) {
        q = p;      //q指向p的父结点
        if (x < p->elemet) {
            p = p->lChild;
        } else if (x > p->elemet) {
            p = p->rChild;
        }
    }

    if (!p) {
        cout<<"Not exist"<<endl;
        return false;
    }

    //p是逻辑上待删除的结点
    //如果结点p有两棵非空子树,找到p的中序遍历次序下的直接后继s,并且r是s的父结点
    if (p->lChild && p->rChild) {
        s = p->rChild;
        r = p;
        while (s->lChild != NULL) {
            r = s;
            s = s->lChild;
        }
        p->elemet = s->elemet;  //将s的元素值复制到p
        p = s;  //复制完元素之后,现在p指向新的真正需要delete掉的结点s
        q = r;  //q指向p的父结点
    }

    //通过上面那个if,此时p最多只有一棵非空子树
    if (p->lChild) {
        c = p->lChild;
    } else if (p->rChild) {
        c = p->rChild;
    }

    //经过上面的判断,此时p还是根结点,说明该根结点最多只有一棵非空子树,且已经被c标识
    if (p == root) {
        root = c;   //让c成为新根
    } else if (p == q->lChild) {
        q->lChild = c;  //让c替代p成为q的左孩子
    } else {
        q->rChild = c;  //让c替代p成为q的右孩子
    }

    //通过上面所有操作,此时p一定是最后需要被delete的结点
    delete (p);
    return true;
}

测试用例：

int main() {
    BSTree<int> bsTree;
    int n = 9;
    int nums[n] = {28, 21, 36, 25, 33, 43, 23, 35, 34};
    for (int i = 0; i < n; ++i) {
        bsTree.Insert(nums[i]);
    }

    cout<<"先序遍历：";
    bsTree.PreOrder(Visit);
    cout<<endl;
    cout<<"中序遍历：";
    bsTree.InOrder(Visit);
    cout<<endl;
    cout<<"后序遍历：";
    bsTree.PostOrder(Visit);
    cout<<endl;
    cout<<"层次遍历：";
    bsTree.LayerOrder(Visit);
    cout<<endl;

    cout<<"测试search成员函数......."<<endl;
    int searchT = 33;
    if (bsTree.Search(searchT)) {
        cout<<searchT<<" exists."<<endl;
    } else {
        cout<<searchT<<" doesn't exist."<<endl;
    }

    int removeNums[3] = {23, 21, 28};
    for (int i = 0; i < 3; ++i) {
        bsTree.Remove(removeNums[i]);
        cout << "删除"<<removeNums[i]<<"之后......." << endl;
        cout << "先序遍历：";
        bsTree.PreOrder(Visit);
        cout << endl;
        cout << "中序遍历：";
        bsTree.InOrder(Visit);
        cout << endl;
        cout << "后序遍历：";
        bsTree.PostOrder(Visit);
        cout << endl;
        cout << "层次遍历：";
        bsTree.LayerOrder(Visit);
        cout << endl;
    }

    return 0;
}

为了便于观察，画出树的图形如下。
这里写图片描述

这里写图片描述

这里写图片描述

这里写图片描述

运行结果如下：

先序遍历：28 21 25 23 36 33 35 34 43 
中序遍历：21 23 25 28 33 34 35 36 43 
后序遍历：23 25 21 34 35 33 43 36 28 
层次遍历：28 21 36 25 33 43 23 35 34 
测试search成员函数.......
33 exists.
删除23之后.......
先序遍历：28 21 25 36 33 35 34 43 
中序遍历：21 25 28 33 34 35 36 43 
后序遍历：25 21 34 35 33 43 36 28 
层次遍历：28 21 36 25 33 43 35 34 
删除21之后.......
先序遍历：28 25 36 33 35 34 43 
中序遍历：25 28 33 34 35 36 43 
后序遍历：25 34 35 33 43 36 28 
层次遍历：28 25 36 33 43 35 34 
删除28之后.......
先序遍历：33 25 36 35 34 43 
中序遍历：25 33 34 35 36 43 
后序遍历：25 34 35 43 36 33 
层次遍历：33 25 36 35 43 34 

Process finished with exit code 0
ancientmoondjay
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用C++实现二叉搜索树的数据结构
weixin_30535843的博客
03-29 1703
需要注意的地方： ①二叉搜索树删除一个指定结点R，若R为叶子结点，则将R的父结点中指向R的指针改为指向nullptr；若R的左右子结点一个为空，一个非空，则将R的父结点中指向R的指针改为指向R的非空子结点；若R有两个非空子结点，则找出R的右子树中的最小值结点，将其删除并将R的值置为该最小值结点的值。 ②对二叉搜索树进行中序遍历，将得到按升...
C++实现数据结构——二分搜索和二叉搜索树
m0_37433111的博客
08-25 149
2020年8月25日 周二 天气晴 【不悲叹过去，不荒废现在，不惧怕未来】 本文目录1. 引言2. 主文件——main.cpp3. BST类 .h文件——bstree.h4. 预编译头文件——stdafx.h参考文献 1. 引言 用C++实现了简单的二分搜索和二叉搜索树（BST）类，成员函数实现了BST和AVL树（高度平衡的BST）的创建，遍历，查找、删除指定结点等功能，主函数中有所有成员函数的测试案例。代码是用VS2019实现的，每个函数的功能都添加了一定注释，由于用了模板，函数的声明和定义都放在了
数据结构之二叉搜索树
Pigeon~的博客
08-18 133
二叉搜索树 二叉搜索树又称二叉排序树，其特点有： 若它的左子树不为空，那么左子树上所有的节点值小于根结点值； 若它的右子树不为空，那么右子树上所有的节点值大于根结点值； 它的左右子树也分别是二叉搜索树。 二叉搜索树插入 思路： 判断二叉搜索树是否为空树，若为空树，直接插入。 二叉搜索树不是空树，根据逻辑确定要插入的位置。如果要插入的值大于根结点，则在根结点的右子树，反之在左子树。 public boolean insert(int val){ Node node = new Nod
二叉搜索树2
weixin_43797452的博客
12-13 61
#include<bits/stdc++.h> using namespace std; struct node { int data; node *lchild,*rchild; }; void insertt(node *&tree,int value)//注意要加&（取地址符）才能每次更新tree 否则不能实现对tree的改变（相当 ...
c语言实现二叉搜索树
03-23
1.实现二叉搜索树的基本操作 2.包括建立，查找，删除，显示 3.得到最长路径和最短路径，并能分别计算长度
「leetcode」450. 删除二叉搜索树中的节点：【递归】【迭代】详解
代码随想录
10-23 550
二叉搜索树删除节点就涉及到结构调整了
数据结构——二叉查找树的详细实现(c++)
lining0420的博客
07-27 1万+
本文实现了二叉查找树的前序遍历（递归与非递归）、中序遍历（递归与非递归）、后序遍历（递归与非递归）、插入过程、删除过程、查找过程等。
binary-search-tree:二叉搜索树 OOP 的简单 C++ 实现
06-27
二叉搜索树（Binary Search Tree...通过阅读和理解这个项目中的源代码，你可以深入学习二叉搜索树的工作原理，以及如何用 C++ 的 OOP 思维来实现数据结构。这对于提升 C++ 编程技能和理解数据结构与算法有着重要作用。
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
总之，二叉搜索树是一种重要的数据结构，它在C++中的实现涉及到节点结构的设计和插入、查找、删除等操作的实现。理解并掌握二叉搜索树的原理和操作是提升算法能力的关键，而自平衡二叉搜索树则进一步提高了在大规模...
二叉搜索树的实现与应用
11-04
本资源是博文【数据结构】二叉搜索树的完整源代码文件，包含K模型搜索树的递归、非递归实现；KV模型搜索树的递归和非递归实现。以及两种模型的测试和应用，主要体现在单词翻译、统计次数、检查单词拼写。可结合以下...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
数据结构平衡二叉排序树
02-13
AVL树是一种自平衡的二叉搜索树，它的每个节点都包含一个平衡因子，这个因子是该节点的左子树高度与右子树高度的差值。平衡因子的取值范围是-1、0或1，这确保了树的高度始终保持在一个相对较小的范围内，从而保证了...
5-28 搜索树判断 (25分)
星夜征程
08-30 2911
5-28 搜索树判断 (25分)对于二叉搜索树，我们规定任一结点的左子树仅包含严格小于该结点的键值，而其右子树包含大于或等于该结点的键值。如果我们交换每个节点的左子树和右子树，得到的树叫做镜像二叉搜索树。现在我们给出一个整数键值序列，请编写程序判断该序列是否为某棵二叉搜索树或某镜像二叉搜索树的前序遍历序列，如果是，则输出对应二叉树的后序遍历序列。 输入格式:输入的第一行包含一个正整数N（≤10
二叉搜索树的实现（C++）
TANGY的博客
04-19 2385
二叉搜索树又称为二叉排序树，它可能是一棵空树，亦或是一棵具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有结点的值都小于根结点的值。 若它的右子树不为空，则右子树上所有结点的值都大于根结点的值。 它的左右子树也分别为二叉搜索树。 二叉搜索树的操作 1.二叉搜索树的查找 实现思路： 若结点不为空： 如果结点的值key == 查找的key，返回该结点； 如果结点的值key ...
二叉搜索树的相关笔记
qq_45591813的博客
12-08 96
二叉搜索树 1 二叉搜索树的概念 1.1 二叉搜索树(二叉排序树 二叉查找树) 根节点值大于其左子树中的所有节点的值 根节点值小于其右子树中的所有节点的值 左右子树都是二叉搜索树 1.2 二叉搜索树的存储结构 typedef * KeyType; typedef struct { //用来比较结点的大小 KeyType key; }ElemType; //这是二叉树的结点定义 typedef struct BiTNode { ElemType data; struct BiTNode *lTree
数据结构二叉查找树C++实现
a363344923的专栏
12-07 464
#include using namespace std; template class BinarySearchTree { public: BinarySearchTree(); BinarySearchTree(const BinarySearchTree& rhs); //copy constructor ~BinarySearchTree(); //destru
二叉树三种遍历方式，先序、中序、后序
热门推荐
justforuse的博客
03-03 7万+
二叉树遍历方式分为三种：先序，中序和后序。 可以以根节点的位置为参考来记遍历方式，在第一个为先序，中间为中序，最后为后序； 即：先序： 根左右；中序：左根右；后序：左右根。 借个图： 之前看过一个视频，关于如何遍历二叉树，只需要围绕二叉树画个轮廓结果就出来了，效果跟此文章类似：https://www.cnblogs.com/shunyu/p/4986288.html 每个节点左上角，...
二叉搜索树
schtonn的博客
01-11 124
0.前置知识 构造一棵树。中序遍历。 1.引入 二叉搜索树是一种神秘的高级数据结构，他可以做很多神秘的高级操作，比如说lognlognlogn排序等等。它把一些数据存在了一棵树中，这棵树严格遵循着一种特定的构造规律。 2.构造规律 一般来说，二叉搜索树遵循这样一个规律： 对于树中任意一颗子树来说，它的根节点的左子树的所有节点都比根节点小，右子树的所有节点都比根节点大。 比如这样。 更直观的理解，...
《C++实现数据结构》：图
ancientmoondjay的博客
03-29 8504
图的内容非常多，边学习边写和图有关的算法也花费了不少时间与精力。写着写着最后都有近1000行代码了。orz…… 接下来详细说说和图有关的都有啥。一、相关概念图分为无向图和有向图。 在无向图中，若图中任意一对顶点都是连通的，则称此图是连通图。 在有向图中，若任意一对顶点u和v间存在一条从u到v的路径和从v到u的路径，则称此图是强连通图。 无向图的一个极大连通子图称为该图的一个连通分量。 有向
数据结构二叉树二叉搜索树堆相关C++代码.docx
11-22
。。。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值