二叉搜索树 (c++非递归版)

最新推荐文章于 2023-02-16 21:22:03 发布
最新推荐文章于 2023-02-16 21:22:03 发布
阅读量334 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 二叉搜索树 c++ 非递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RGBMarco/article/details/76925220
版权

400多行代码(其实还有好多API没完成),请接受恐惧的代码吧得到节点count是递归的(为了不太复杂),下面也给出了测试代码

BST.h

#pragma once
#include <stdexcept>
#include <stack>
template<typename Key, typename Value>
class BST
{
private:
    class Node
    {
    public:
        Node* left = nullptr;
        Node* right = nullptr;
        Key key;
        Value value;
        int count = 0;
    public:
        Node(const Key& k, const Value& v, const int& c) :key(k), value(v), count(c)
        {
        }
    };
    Node* root = nullptr;
private:
/********************************************
函数名称: size
函数说明: 返回二叉树节点个数
返回值:   int
********************************************/
    int size(Node* r)
    {
        if (r == nullptr)
            return 0;
        return r->count;
    }
/******************************************
函数名称:  sync_size
函数说明:  更新各节点的count值
返回值:    void
*******************************************/
    void sync_size(Node* r)
    {
        if (r == nullptr)
            return;
        sync_size(r->left);
        sync_size(r->right);
        r->count = size(r->left) + size(r->right) + 1;
        return;
    }
/*******************************************
函数名称: put
函数说明: 存储节点于二叉搜索树
返回值:   Node*
*******************************************/
    Node* put(Node* r, const Key& k, const Value& v)
    {
        if (r == nullptr)
            return new Node(k, v, 1);
        Node* curr = r;
        while (true)
        {
            if (curr->key > k)
            {
                if (curr->left == nullptr)
                {
                    curr->left = new Node(k, v, 1);
                    break;
                }
                else
                    curr = curr->left;
            }
            else if (curr->key < k)
            {
                if (curr->right == nullptr)
                {
                    curr->right = new Node(k, v, 1);
                    break;
                }
                else
                    curr = curr->right;
            }
            else
            {
                curr->value = v;
                return r;
            }
        }
        sync_size(r);
        return r;
    }
/*******************************************
函数名称:  get
函数说明:  得到二叉树key对应value
返回值:    Value
******************************************/
    Value get(Node* r, const Key& key)
    {
        if (r == nullptr)
            throw std::out_of_range("can't get the value of key");
        while (true)
        {
            if (r->key > key)
            {
                if (r->left == nullptr)
                    throw  std::out_of_range("can't get the value of key");
                else
                    r = r->left;
            }
            else if (r->key < key)
            {
                if (r->right == nullptr)
                    throw  std::out_of_range("can't get the value of key");
                else
                    r = r->right;
            }
            else
                return r->value;
        }
    }
/******************************************
函数名称: min
函数说明: 取得二叉树key最小的节点
返回值:   Node*
********************************************/
    Node* min(Node* r)
    {
        if (r == nullptr)
            throw std::out_of_range("can't gain the min");
        while (true)
        {
            if (r->left == nullptr)
                return r;
            else
                r = r->left;
        }
    }
/******************************************
函数名称: max
函数说明: 取得二叉树里key最大的节点
返回值:   Node*
*******************************************/
    Node* max(Node* r)
    {
        if (r == nullptr)
            throw std::out_of_range("can't gain the max");
        while (true)
        {
            if (r->right == nullptr)
                return r;
            else
                r = r->right;
        }
    }
/******************************************
函数名称: deleteMin
函数说明: 删除二叉树中key最小的节点
返回值:   Node*
*******************************************/
    Node* deleteMin(Node *r)
    {
        if (r == nullptr)
            return nullptr;
        Node* curr = r;
        Node* pre = nullptr;
        while (true)
        {
            if (curr->left == nullptr)
            {
                Node* temp = curr;
                curr = curr->right;
                delete temp;
                if (pre != nullptr)
                    pre->left = curr;
                else
                    r = curr;
                sync_size(r);
                return r;
            }
            else
            {
                pre = curr;
                curr = curr->left;
            }
        }
    }
/******************************************
函数名称: deleteMax
函数说明: 删除二叉树key最大的节点
返回值:   void
*******************************************/
    Node* deleteMax(Node *r)
    {
        if (r == nullptr)
            return nullptr;
        Node* curr = r;
        Node* pre = nullptr;
        while (true)
        {
            if (curr->right == nullptr)
            {
                Node* temp = curr;
                curr = curr->left;
                delete temp;
                if (pre != nullptr)
                    pre->right = curr;
                else
                    r = curr;
                sync_size(r);
                return r;
            }
            else
            {
                pre = curr;
                curr = curr->right;
            }
        }
    }
/******************************************
函数名称: before_display
函数说明: 中序遍历二叉树打印节点value
返回值:   void
*******************************************/
    void before_display(Node* r)
    {
        if (r == nullptr)
            return;
        stack<Node*> s;
        while (r != nullptr || !s.empty())
        {
            if (r != nullptr)
            {
                s.push(r);
                r = r->left;
            }
            else
            {
                r = s.top();
                cout << r->value << ends;
                s.pop();
                r = r->right;
            }
        }
    }
/******************************************
函数名称:  erase
函数说明:  删除特定key的节点
*******************************************/
    Node* erase(Node* r, const Key& k)
    {
        if (r == nullptr)
            return nullptr;
        Node* curr = r;
        Node* pre = nullptr;
        while (curr != nullptr)
        {
            if (curr->key > k)
            {
                pre = curr;
                curr = curr->left;
            }
            else if (curr->key < k)
            {
                pre = curr;
                curr = curr->right;
            }
            else
            {
                if (curr->left == nullptr)
                {
                    if (pre != nullptr && pre->right == curr)
                    {
                        Node* temp = curr;
                        curr = curr->right;
                        delete temp;
                        pre->right = curr;
                        sync_size(r);
                        return r;
                    }
                    else if (pre != nullptr && pre->left == curr)
                    {
                        Node* temp = curr;
                        curr = curr->right;
                        delete temp;
                        pre->left = curr;
                        sync_size(r);
                        return r;
                    }
                    else
                    {
                        Node* temp = curr;
                        curr = curr->right;
                        delete temp;
                        r = curr;
                        sync_size(r);
                    }
                }
                else if (curr->right == nullptr)
                {
                    if (pre != nullptr && pre->right == curr)
                    {
                        Node* temp = curr;
                        curr = curr->left;
                        delete temp;
                        pre->right = curr;
                        sync_size(r);
                        return r;
                    }
                    else if (pre != nullptr && pre->left == curr)
                    {
                        Node* temp = curr;
                        curr = curr->left;
                        delete temp;
                        pre->left = curr;
                        sync_size(r);
                        return r;
                    }
                    else
                    {
                        Node* temp = curr;
                        curr = curr->left;
                        delete temp;
                        r = curr;
                        sync_size(r);
                        return r;
                    }
                }
                else
                {
                    if (pre != nullptr)
                    {
                        Node* get = min(curr->right);
                        get->right = deleteMin(curr->right);
                        get->left = curr->left;
                        if (pre->right == curr)
                            pre->right = get;
                        else
                            pre->left = get;
                        delete curr;
                        sync_size(r);
                        return r;
                    }
                    else
                    {
                        Node* get = min(curr->right);
                        get->right = deleteMin(curr->right);
                        get->left = curr->left;
                        r = get;
                        delete curr;
                        sync_size(r);
                        return r;
                    }
                }
            }
        }
    }
/*******************************************
函数名称:  floor
函数说明:  向下取整返回第一个key<= k的节点
返回值:    Node*
********************************************/
    Node* floor(Node* r, const Key& k)
    {
        if (r == nullptr)
            return nullptr;
        Node* pre = nullptr;
        while (true)
        {
            if (r->key == k)
                return r;
            else if (r->key > k)
            {
                if (r->left == nullptr)
                {
                    return pre;
                }
                else
                    r = r->left;
            }
            else
            {
                if (r->right == nullptr)
                    return r;
                else
                {
                    pre = r;
                    r = r->right;
                }
            }
        }
    }
public:
    int size()
    {
        return size(root);
    }
    void put(const Key& k, const int& v)
    {
        root = put(root, k, v);
    }
    Value get(const Key& k)
    {
        return get(root, k);
    }
    Key min()
    {
        return min(root)->key;
    }
    Key max()
    {
        return max(root)->key;
    }
    void deleteMin()
    {
        root = deleteMin(root);
    }
    void deleteMax()
    {
        root = deleteMax(root);
    }
    void before_display()
    {
        before_display(root);
    }
    void erase(const Key& k)
    {
        root = erase(root, k);
    }
    Key floor(const Key& k)
    {
        Node* ret;
        if ((ret = floor(root, k)) == nullptr)
            throw std::out_of_range("can't floor");
        else
            return ret->key;
    }
};

main.cpp

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

int main()
{
    BST<double, int> bst;
    for (int i = 0; i < 10; ++i)
        bst.put(i + 0.1, i);
    cout << "size: " << bst.size() << endl;
    try
    {
        cout << bst.get(1.1) << endl;
        bst.deleteMin();
        bst.deleteMax();
        bst.erase(3.1);
        cout << "min: " << bst.min() << endl;
        cout << "max: " << bst.max() << endl;
        cout << bst.size() << endl;
        cout << bst.floor(5.0) << endl;
    }
    catch (const exception& e)
    {
        cout << e.what();
    }
    bst.before_display();
    system("pause");
    return 0;
}

运行:

这里写图片描述

RGBMarco
关注
专栏目录
C++数据结构： 二叉搜索树 （非递归）
earayu的博客
11-17 583
理想情况下BST的插入删除查找花费的时间都是对数级别的，但我们肯定不能依赖“理想情况”。基于下面3个理由： 1. 很多时候输入得序列都是有序或基本有序的 2. 访问一个节点过后很可能再次访问这个节点，或者这个节点附近的节点。 3. 多次删除过后会破坏树的平衡性（可以改变一下删除方式来解决，但是这样的代价比较大）而BST在最差的请况下会退化成一个链表，这显然不是我们想要的结果。所以感觉BST的实
C++二叉搜索树的递归和非递归实现
qq_53413129的博客
05-09 691
二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二叉搜索树的应用 1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。 比如：给一个单词word，判断该单词是否拼写正确，具体方式如下： 以单词集合中的每个单词作为key，构建一棵二叉搜索树 在二叉搜索树中
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
二叉搜索树的非递归C++实现
weixin_33890499的博客
07-14 95
2019独角兽企业重金招聘Python工程师标准>>> ...
C++实现二叉搜索树基本操作（递归+非递归+应用）
stay_the_course的博客
04-02 398
基本概念不再多讲，看下面的例子有如图的序列，用插入法建立二叉搜索树并完成相关操作：代码：#pragma once #include <iostream> #include <assert.h> #include <string> using namespace std;//结点定义 template <class K> struct SearchBinaryTreeNode { K _key
c++ 二叉查找树 非递归（先序、中序、后序）遍历
jxluoix的专栏
10-17 2109
c++ 二叉查找树 非递归（先序、中序、后序）遍历关键词： c++    二叉查找树    非递归（先序、中序、后序）遍历                                           FtpDownFtpDown4162006-06-04T07:11:00Z2006-06-0
C++实现二叉搜索树（递归&非递归）
her的博客
06-14 2741
二叉搜索树（Binary Search Tree）的性质： 1、每个节点都有一个作为搜索关键码的key，并且所有节点的key都不相同。 2、左子树上的key值都小于根节点的key值。 3、右子树上的key值都大于根节点的key值。 4、左右子树都是二叉搜索树。 如下图为一颗二叉搜索树 实现： 二叉搜索树的插入： 二叉树的插入是根据要插入节点的key值找一个合适的位置插入节点，如果
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
二叉树遍历非递归C++
qq_36711295的博客
07-29 821
二叉树遍历非递归C++题目链接二叉树的前序遍历思路分析代码实现二叉树的中序遍历思路分析代码实现二叉树的后序遍历思路分析代码实现一点点题外话 题目链接 二叉树的前序遍历 144. 二叉树的前序遍历 思路分析 既然要使用非递归的方式，那就必须要借助栈来进行处理，前序遍历的遍历顺序为中左右，因此我们从根节点开始遍历，将遇到的每一个节点入栈，并保存遇到的每一个节点，我们不断的去访问左子树，当访问到最后一个节点时，此时就该访问右子树，当栈不为空或当前节点不为空时，就继续进入循环 代码实现 /** * Defini
【C++】二叉搜索树的实现（递归和非递归实现）
最新发布
Ahaooooooo的博客
02-16 937
模拟实现BSTree
小白进阶之动态规划-最优二叉搜索树
hola_f的博客
06-28 547
问题描述： 给定关键词序列k=(k1,k2,...,kn)及其相应的概率pi，以及 n+1个伪关键字d0,d1,...,dn不在k值中。其中d0表示小于k1的值，dn表示大于kn的值，对于i=1,2,...,n-1，di表示在 ki和ki+1之间的值，用qi表示其搜索概率。用w(i,j)表示关键字ki,ki+1,...,kj的概率之和，e[i,j]表示包含关键字 ki,ki+1,...,kj
C++递归及非递归实现二叉搜索树的创建，插入，查找，删除
guoxu00的博客
08-27 2605
一.非递归实现二叉搜索树的插入，查找，删除 #include&lt;iostream&gt; using namespace std; template&lt;class T&gt; struct BSTreeNode{ BSTreeNode&lt;T&gt;* _pLeft; BSTreeNode&lt;T&gt;* _pRight; T _data; BSTreeNode(co...
非递归实现二叉树遍历（附c++完整代码）
桑凯旋的博客
10-17 2万+
先序、中序和后序遍历过程：遍历过程中经过结点的路线一样，只是访问各结点的时机不同。 从图中可以看到，前序遍历在第一次遇见元素时输出，中序遍历在第二次遇见元素时输出，后序遍历在第三次遇见元素时输出。 非递归算法实现的基本思路：使用堆栈 一、前序遍历 1、递归实现 遍历过程为： 访问根结点； 先序遍历其左子树； 先序遍历其右子树。 void ProOrderTraverse(BiTree tre...
【算法学习】最优二叉查找树（动态规划）
热门推荐
计算机专业同学的充电站。
10-19 8万+
一、什么是最优二叉查找树 最优二叉查找树： 给定n个互异的关键字组成的序列K=，且关键字有序（k1 图一显示了给定上面的概率分布pi、qi，生成的两个二叉查找树的例子。图二就是在这种情况下一棵最优二叉查找树。 概率分布： i 0 1 2 3 4 5 p
二叉搜索树(Binary Search Tree)的递归和非递归代码实现(C++)
dawning
03-11 1423
二叉搜索树简单介绍二叉搜索树(Binary Search Tree)是满足： 左子树的根节点比树的根节点小 右子树的根节点比树的根节点大 的二叉树。 由于这种数据结构具有很高的查询效率，故多用于需要索引的场合。
算法：C++实现二叉树遍历（递归、非递归）
叶赫那拉坤的博客
07-03 1万+
完成二叉树创建并消除节点值相同的节点，然后分别采用前序中序后序三种方式输出结果。#include<iostream> struct Node{ int value; Node *left; Node *right; Node(int data):value(data),left(NULL),right(NULL){} };void inertNode(Node *no
动态规划之-最优二叉查找树
Creek Shi
09-09 643
// 最优二叉查找树.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #define N 5// the number of real node using namespace std; int _tmain(int argc, _TCHAR* argv[]) { double p[N+1] = {0, 0.15
C++实现的二叉搜索树深入解析
资源摘要信息:"二叉树-基于C++实现的二叉搜索树.zip" 知识点一：二叉树基础概念 二叉树是每个节点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。二叉树在计算机科学中有广泛的应用，比如用于构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值