C++中二叉树进阶

于 2024-07-18 20:52:40 发布
阅读量784 收藏 31
点赞数 31
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2202_75331338/article/details/140532714
版权

目录

1.内容安排说明

2.二叉搜索树

二叉搜索树概念

二叉搜索树操作

二叉搜索树的查找

二叉搜索树的插入

二叉搜索树的删除

二叉搜索树的实现

二叉搜索树的应用

二叉搜索树的性能分析

1.内容安排说明

二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为：

1.map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构

2.二叉搜索树的特性了解，有助于更好的理解map和set的特性

3.二叉树中部分面试题稍微有些难度，在前面讲解大家不同容易接受，且时间长容易忘

4.有些OJ题使用C语言方式实现比较麻烦，比如有些地方要返回动态开辟的二维数组，非常麻烦。

因此本节借二叉树搜索树，对二叉树部分进行收尾总结。

2.二叉搜索树

二叉搜索树概念

二叉搜索树（BST，Binary Search Tree）又称二叉排序树或二叉查找树，它或者是一棵空树，或者是具有以下性质的二叉树：

❍ 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

❍ 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

❍ 它的左右子树也分别为二叉搜索树

❍ 二叉搜索树的中序遍历为递增排序

二叉搜索树操作

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

 

二叉搜索树的查找

1️⃣ 从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。

2️⃣ 最多查找高度次，走到空，还没找到，这个值不存在

二叉搜索树的插入

插入的具体过程如下：

1️⃣ 树为空，则直接新增节点，赋值给root指针

2️⃣ 树不空，按二叉搜索树性质查找插入位置，插入新节点

二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回，否则要删除的节点可能分下面四种情况：

1️⃣ 要删除的节点无孩子节点

2️⃣ 要删除的结点只有左孩子节点

3️⃣ 要删除的结点只有右孩子结点

4️⃣ 要删除的结点有左、右孩子结点

看起来有待删除节点有4种情况，实际情况 a 可以和情况 b 或者 c 合并起来，因此真正的删除过程如下：

❍ 情况b：删除该结点且使被删除节点的双亲节点指向被删除节点的左孩子节点--直接删除

 

❍ 情况c：删除该结点且使被删除节点的双亲节点指向被删除节点的右孩子节点--直接删除 

❍ 情况d：在它的右子树中寻找中序下的第一个节点（关键码最小）｜｜ 左子树的最大的节点，用它的值填补到被删除节点中，再来处理该结点的删除问题--（替换法删除） 

或者 

二叉搜索树的实现

//
//  SearchBinaryTree.h
//  二叉搜索树
//
//  Created by 南毅 on 2024/7/10.
//

#include<iostream>
using namespace std;

//二叉搜索树节点
template<class K>
struct BSTNode{
    K _key;
    BSTNode<K>* _left;
    BSTNode<K>* _right;
    
    BSTNode(const K& key)
    :_key(key),
    _left(nullptr),
    _right(nullptr){
        
    }
};

//二叉搜索树
template<class K>
class BSTree{
private:
    typedef BSTNode<K> Node;
    Node* _root = nullptr;
    
    void _InOrder(Node* root){
        if(root == nullptr)
            return;
        
        _InOrder(root->_left);
        cout << root->_key <<" ";
        _InOrder(root->_right);
    }

public:
    
    void InOrder(){
        _InOrder(_root);
        cout << endl;
    }
    
    //二叉搜索树的查找
    bool Find(const K& key){
        Node* cur = _root;
        while (cur) {
            if(cur->_key < key)
            {
                cur = cur -> _right;
            }
            else if(cur->_key > key)
            {
                cur = cur -> _left;
            }else
            {
                return true;
            }
        }
        
        return false;
    }
    
    
    //二叉树的插入
    bool Insert(const K& key){
        //如果树不存在
        if(_root == nullptr)
        {
            _root = new Node(key);
            return true;
        }
        
        //树存在
        //1.找到待插入节点的位置（借助二叉搜索树性质）
        //2.与父母亲 相连
        Node* parents = nullptr;
        Node* cur = _root;
        
        while (cur) {
            if(cur->_key < key)
            {
                parents = cur;
                cur = cur -> _right;
            }
            else if(cur->_key > key)
            {
                parents = cur;
                cur = cur -> _left;
            }else
            {
                //二叉树搜索性质：如果有重复不插入
                //插入失败
                return false;
            }
        }
        //找到待插入节点位置
        cur = new Node(key);
        //比父母节点大 做右子树
        if(parents->_key < key){
            parents->_right = cur;
        }else
        {
            parents->_left = cur;
        }
        //插入成功
        return true;
    }
    
    //删除二叉搜索树中某个节点
    bool Erase(const K& key){
        Node* parent = nullptr;
        Node* cur = _root;
        //找到 待删除的节点
        while(cur){
            if(cur->_key < key){
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key){
                parent = cur;
                cur = cur->_left;
            }
            else{
                //删除
                //0-1个孩子情况
                if(cur->_left == nullptr){
                    //如果是删除根节点
                    if(parent == nullptr){
                        _root = cur->_right;
                    }else{
                        //删除的不是根节点
                        if(parent->_left == cur){
                            parent->_left = cur->_right;
                        }else{
                            parent->_right = cur->_right;
                        }
                    }
                    delete cur;
                    return true;
                }
                else if(cur->_right == nullptr)
                {
                    if(parent == nullptr){
                        _root = cur->_left;
                    }else{
                        if(parent->_left == cur){
                            parent->_left = cur->_left;
                        }else{
                            parent->_right = cur->_left;
                        }
                    }
                    delete cur;
                    return true;
                }
                else{
                    // 2个孩子的情况
                    // 找左最大 右最小
                    // 这里我们找右最小 作为替代节点
                    Node* rightMinP = cur;
                    Node* rightMin = cur->_right;
                    while(rightMin->_left){
                        rightMinP = rightMin;
                        rightMin = rightMin->_left;
                    }
                    // 替换
                    cur->_key = rightMin->_key;
                    if (rightMinP->_left == rightMin) {
                        rightMinP->_left = rightMin->_right;
                    }else{
                        rightMinP->_right = rightMin->_right;
                    }
                    
                    delete rightMin;
                    return true;
                    
                }
            }
        }
        return false;
    }
    
    
};

 

二叉搜索树的应用

1️⃣ K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到

的值。

比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

❍ 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树

❍ 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2️⃣ KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方

式在现实生活中非常常见：

❍ 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；

❍ 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出

现次数就是<word, count>就构成一种键值对。

namespace keyValue
{
template<class K,class V>
struct BSTNode{
    K _key;
    V _value;
    BSTNode<K,V>* _left;
    BSTNode<K,V>* _right;
    
    BSTNode(const K& key,const V& value)
    :_key(key),
    _value(value),
    _left(nullptr),
    _right(nullptr){
        
    }
};

//二叉搜索树
template<class K,class V>
class BSTree{
private:
    typedef BSTNode<K,V> Node;
    Node* _root = nullptr;
    
    void _InOrder(Node* root){
        if(root == nullptr)
            return;
        
        _InOrder(root->_left);
        cout << root->_key <<" ";
        _InOrder(root->_right);
    }
    
    // 后续遍历删除
    void Destroy(Node* root)
    {
        if (root == nullptr)
            return;

        Destroy(root->_left);
        Destroy(root->_right);
        delete root;
    }

    Node* Copy(Node* root)
    {
        if (root == nullptr)
            return nullptr;

        Node* newRoot = new Node(root->_key, root->_value);
        newRoot->_left = Copy(root->_left);
        newRoot->_right = Copy(root->_right);

        return newRoot;
    }
    
public:
    
    BSTree() = default;
    
    BSTree(const BSTree<K, V>& t)
    {
        _root = Copy(t._root);
    }

    ~BSTree()
    {
        Destroy(_root);
        _root = nullptr;
    }
    
    void InOrder(){
        _InOrder(_root);
        cout << endl;
    }
    
    //二叉搜索树的查找
    Node* Find(const K& key){
        Node* cur = _root;
        while (cur) {
            if(cur->_key < key)
            {
                cur = cur -> _right;
            }
            else if(cur->_key > key)
            {
                cur = cur -> _left;
            }else
            {
                return cur;
            }
        }
        
        return nullptr;
    }
    
    
    //二叉树的插入
    bool Insert(const K& key,const V& value){
        //如果树不存在
        if(_root == nullptr)
        {
            _root = new Node(key,value);
            return true;
        }
        
        //树存在
        //1.找到待插入节点的位置（借助二叉搜索树性质）
        //2.与父母亲 相连
        Node* parents = nullptr;
        Node* cur = _root;
        
        while (cur) {
            if(cur->_key < key)
            {
                parents = cur;
                cur = cur -> _right;
            }
            else if(cur->_key > key)
            {
                parents = cur;
                cur = cur -> _left;
            }else
            {
                //二叉树搜索性质：如果有重复不插入
                //插入失败
                return false;
            }
        }
        //找到待插入节点位置
        cur = new Node(key,value);
        //比父母节点大 做右子树
        if(parents->_key < key){
            parents->_right = cur;
        }else
        {
            parents->_left = cur;
        }
        //插入成功
        return true;
    }
    
    //删除二叉搜索树中某个节点
    bool Erase(const K& key){
        Node* parent = nullptr;
        Node* cur = _root;
        //找到 待删除的节点
        while(cur){
            if(cur->_key < key){
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key){
                parent = cur;
                cur = cur->_left;
            }
            else{
                //删除
                //0-1个孩子情况
                if(cur->_left == nullptr){
                    //如果是删除根节点
                    if(parent == nullptr){
                        _root = cur->_right;
                    }else{
                        //删除的不是根节点
                        if(parent->_left == cur){
                            parent->_left = cur->_right;
                        }else{
                            parent->_right = cur->_right;
                        }
                    }
                    delete cur;
                    return true;
                }
                else if(cur->_right == nullptr)
                {
                    if(parent == nullptr){
                        _root = cur->_left;
                    }else{
                        if(parent->_left == cur){
                            parent->_left = cur->_left;
                        }else{
                            parent->_right = cur->_left;
                        }
                    }
                    delete cur;
                    return true;
                }
                else{
                    // 2个孩子的情况
                    // 找左最大 右最小
                    // 这里我们找右最小 作为替代节点
                    Node* rightMinP = cur;
                    Node* rightMin = cur->_right;
                    while(rightMin->_left){
                        rightMinP = rightMin;
                        rightMin = rightMin->_left;
                    }
                    // 替换
                    cur->_key = rightMin->_key;
                    if (rightMinP->_left == rightMin) {
                        rightMinP->_left = rightMin->_right;
                    }else{
                        rightMinP->_right = rightMin->_right;
                    }
                    
                    delete rightMin;
                    return true;
                    
                }
            }
        }
        return false;
    }
    
    
};
}

二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：$log_2 N$

最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：$\frac{N}{2}$

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上场了。
 

c无序
关注
专栏目录
C/C++ 四叉树详解及实现源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-30 7633
四叉树（Quadtree）是一种多叉树的形式，用于处理二维空间中的数据。它将空间划分为四个相等的象限，并在每个象限内递归地构建四叉树，直到满足某个条件停止划分。这是一个简单的四叉树实现示例，可以根据需要进行扩展和优化。
C++从入门到进阶的系列书籍推荐（22本书）
热门推荐
dvlinker的技术专栏
11-05 3万+
要多读书，读好书！一本书要多读几遍才好，每次都可能有新的收获！特别在是有一定的工作年限和工作经验之后！读书百遍，其义自见！ 下面就给大家推荐一下C++程序员进阶需要读的经典书籍： 1、C++入门书籍 C++是在C语言的基础上发展而来的，要学习C++之前需要先学习C语言。有了C语言基础之后再去学习C++。 1.1、C语言程序设计（谭浩强） 该书被公认为学习C语言程序设计的优秀教材，被全国大多数高校选用，是学习C语言的主流用书。本书比较通俗易懂，是初入者必备的书籍。 ........
【C++】二叉搜索树
knous
07-27 353
二叉搜索树及模拟实现，后续更新练习题
C++ 二叉搜索树
m0_61548909的博客
07-23 628
或者是具有以下性质的二叉树若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树。...
二叉搜索树（C++）
mmz123_的博客
01-27 2569
文章目录二叉搜索树概念与操作二叉搜索树的概念二叉搜索树的操作查找插入删除二叉搜索树的应用二叉树的性能分析 二叉搜索树概念与操作 二叉搜索树的概念 二叉搜索树又称二叉排序树，若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；若它的右子树不为空，则右子树上所有节点的值都大于根节点的值，它的左右子树也分别未二叉搜索树。也可以是一颗空树。 int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 }; 二叉搜索树的操作 查找 迭代： Node* Find(const K&am
C++ —— 二叉搜索树
原来45的博客
09-17 1115
二叉搜索树概念 二叉搜索树操作 1. 二叉搜索树的查找 2.二叉搜索树的插入 3. 二叉搜索树的删除 二叉搜索树的应用 1. K模型 2. KV模型 二叉搜索树的性能分析 二叉搜索树的实现（K&&KV）和测试（KV）
【 C++ 】二叉搜索树
bit_zyx的博客
09-03 1432
目录 1、二叉搜索树的概念 2、二叉搜索树的实现 ①、结点类 ②、二叉搜索树的类 2.1、默认成员函数 构造函数 拷贝构造函数 赋值运算符重载函数 析构函数 2.2、中序遍历 2.3、Insert插入函数 ............
使用C++实现四叉树的代码
08-10
记录了四叉树的原理，实现代码和思路 附有完整的C++代码。
C++开发工程师高级进阶课程-提升C++面试和开发能力.zip
最新发布
01-20
《C++开发工程师高级进阶课程-提升C++面试和开发能力》的资源包，旨在帮助C++开发者进一步提升自己的专业技能，以适应更高级别的面试挑战和开发工作。这份资料集涵盖了C++语言的核心知识，包括但不限于C++面试常见...
C++ 中二分查找递归非递归实现并分析
08-30
C++ 中二分查找递归非递归实现并分析 在 C++ 编程中，二分查找是一种常用的查找算法，通过将数组分为两部分，并逐步缩小查找范围来找到目标元素。今天我们将介绍 C++ 中二分查找的递归和非递归实现，并对其进行分析...
C++--二叉搜索树
qq_46659987的博客
05-16 367
二叉搜索树1. 二叉搜索树2. 二叉搜索树的操作2.1 二叉搜索树的查找2.2 二叉搜索树的插入2.3 二叉搜索树的删除3. 二叉搜索树的性能分析 1. 二叉搜索树 二叉搜索树又称二叉排序树， 性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别是二叉搜索树； 可以是一棵空树。 2. 二叉搜索树的操作 二叉树的结构 template<class T> struct BNode { T
【c++】二叉搜索树
HenryBlog
04-20 417
目录一、概念二、操作2.1 查找2.2 插入2.3 删除 一、概念 二叉搜索树又称二叉排序树，它或者是一颗空树 特性： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若他的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、操作 2.1 查找 2.2 插入 我们需要判断树为空，则直接插入，return true 树不为空，按二叉搜索树性质查找插入位置，插入新节点 这里当我们new出一个新的节点需要注意，把他进行链接，不然出了此函数就栈销毁了，导
c++——二叉搜索树
陌上人如玉，公子世无双。
08-17 374
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。 键值对： 用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值， value表示与key对应的信息。 二叉搜索树： 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： ...
C++ Builder基础与进阶：Word 文档解析
"C++_Builder基础与进阶 Word 文档" C++ Builder 是一个集成开发环境，主要用于构建Windows平台的应用程序。它结合了C++语言的高效性和VCL（Visual Component Library）库的强大功能，使得开发者能够快速创建图形...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值