C++模板实现二叉查找树(二 节点删除)

最新推荐文章于 2022-11-05 15:21:55 发布
最新推荐文章于 2022-11-05 15:21:55 发布
阅读量276 收藏
点赞数
分类专栏： 数据结构与算法 C/C++ 模板与泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luanzheng_365/article/details/68173833
版权

接着上一篇内容，继续实现二叉树节点的删除。结点的删除主要有两种方法，合并删除与复制删除。
合并删除的思想是先找到要删除的节点，如果要删除的节点同时有左右子树，则将左（或右）子树挂在要删除的节点的位置，之后将右（或左）子树挂在原来左（或右）子树的最右（或左）节点的右（或左）子树位置。

复制删除的思想是先找到要删除的节点，如果要删除的节点同时有左右子树，则进入到其左（或右）子树的最右（或左）节点，将该节点的内容复制到要删除的节点位置。之后若该节点仍有左（或右）子树（此时最多只会有一个子树，因为已经是最左或最右节点了），则将其子树挂在其父节点下面即可。然后该节点可以被删除。

C++代码如下：
头文件是上一节的扩充，增加了delete方法和判断节点状态（叶，单左右，全左右）方法。源文件中只列出了增加的方法。使用100*100000次的插入删除测试，程序运行正常，并且也没有内存泄露发生。

#ifndef _BIN_SEARCH_TREE_H_
#define _BIN_SEARCH_TREE_H_
#include "Constant.h"

template <class T>
class BinNode
{
public:
    BinNode();
    BinNode(const T& data, BinNode<T> *l = NULL, BinNode<T> *r = NULL);
    bool isLeafNode();
    bool isOnlyoneChildNode(bool &leftOrRight);
    T data;
    BinNode* left;
    BinNode* right;
};

template <class T, unsigned int capacity>
class BinSearchTree
{
public:
    BinSearchTree();
    bool isEmpty();
    bool isFull();
    bool insert(T data);
    bool delViaMerge(T data);
    bool delViaCopy(T data);
private:
    unsigned int treeNodeNum;
    BinNode<T> *root;
};

#endif

C++源文件如下：

#include "BinSearchTree.h"

... ...
template<class T>
bool BinNode<T>::isLeafNode()
{
    bool rs = false;
    if ((NULL == left) && (NULL == right))
        rs = true;
    return rs;
}

template<class T>
bool BinNode<T>::isOnlyoneChildNode(bool &leftOrRight)
{
    bool rs = false;
    if ((NULL == left) && (NULL != right))
    {
        leftOrRight = true;
        rs = true;
    }
    else if ((NULL != left) && (NULL == right))
    {
        leftOrRight = false;
        rs = true;
    }
    else
    {
        rs = false;
    }
    return rs;
}

template<class T, unsigned int capacity>
bool BinSearchTree<T, capacity>::delViaMerge(T data)
{
    bool rs = false;
    if (isEmpty())
    {
        rs = false;
    }
    else
    {
        bool findOrNot = false;
        BinNode<T> *preIter = NULL;
        BinNode<T> *iter = root;
        while (NULL != iter)
        {
            if (data < iter->data)
            {
                preIter = iter;
                iter = iter->left;
            }
            else if(data > iter->data)
            {
                preIter = iter;
                iter = iter->right;
            }
            else //find the node to del
            {
                findOrNot = true;
                bool hasLeftOrRight = false;
                if (iter->isLeafNode())
                {
                    if (NULL != preIter)
                    {
                        if (preIter->left == iter)
                        {
                            delete iter;
                            iter = NULL;
                            preIter->left = NULL;
                        }
                        else
                        {
                            delete iter;
                            iter = NULL;
                            preIter->right = NULL;
                        }
                    }
                    else
                    {
                        delete iter;
                        iter = NULL;
                        root = NULL;
                    }

                }
                else if (iter->isOnlyoneChildNode(hasLeftOrRight))
                {
                    BinNode<T> *needDeleteBuffer = iter;
                    if (hasLeftOrRight)  //true means only right
                    {
                        iter = iter->right;
                    }
                    else     //false means only left
                    {
                        iter = iter->left;
                    }
                    if (NULL == preIter)
                    {
                        root = iter;
                    }
                    else
                    {
                        if (preIter->left == needDeleteBuffer)
                        {
                            preIter->left = iter;
                        }
                        else
                        {
                            preIter->right = iter;
                        }
                    }
                    delete needDeleteBuffer;
                    needDeleteBuffer = NULL;
                }
                else  //has both left and right child
                {
                    BinNode<T> *needDeleteBuffer = iter;
                    iter = iter->left;        //turn left
                    if (NULL == preIter)
                    {
                        root = iter;
                    }
                    else
                    {
                        if (preIter->left == needDeleteBuffer)
                        {
                            preIter->left = iter;
                        }
                        else
                        {
                            preIter->right = iter;
                        }
                    }
                    BinNode<T> *rightestNodeInLeftTree = NULL;
                    while (NULL != iter)
                    {
                        rightestNodeInLeftTree = iter;
                        iter = iter->right;
                    }
                    rightestNodeInLeftTree->right = needDeleteBuffer->right;
                    delete needDeleteBuffer;
                    needDeleteBuffer = NULL;
                }
                treeNodeNum--;
                rs = true;
                break;
            }
        }
        if (false == findOrNot)
        {
            rs = false;
        }
    }
    return rs;
}

template<class T, unsigned int capacity>
bool BinSearchTree<T, capacity>::delViaCopy(T data)
{
    bool result = false;
    if (isEmpty())
    {
        result = false;
    }
    else
    {
        bool findOrNot = false;
        BinNode<T> *preIter = NULL;
        BinNode<T> *iter = root;
        while (NULL != iter)
        {
            if (data < iter->data)
            {
                preIter = iter;
                iter = iter->left;
            }
            else if (data > iter->data)
            {
                preIter = iter;
                iter = iter->right;
            }
            else  //Find the node
            {

                findOrNot = true;
                bool hasLeftOrRight = false;
                if (iter->isLeafNode())
                {
                    if (NULL != preIter)
                    {
                        if (preIter->left == iter)
                        {
                            delete iter;
                            iter = NULL;
                            preIter->left = NULL;
                        }
                        else
                        {
                            delete iter;
                            iter = NULL;
                            preIter->right = NULL;
                        }
                    }
                    else
                    {
                        delete iter;
                        iter = NULL;
                        root = NULL;
                    }
                }
                else if (iter->isOnlyoneChildNode(hasLeftOrRight))
                {
                    BinNode<T> *needDeleteBuffer = iter;
                    if (hasLeftOrRight)  //true means only right
                    {
                        iter = iter->right;
                    }
                    else     //false means only left
                    {
                        iter = iter->left;
                    }
                    if (NULL == preIter)
                    {
                        root = iter;
                    }
                    else
                    {
                        if (preIter->left == needDeleteBuffer)
                        {
                            preIter->left = iter;
                        }
                        else
                        {
                            preIter->right = iter;
                        }
                    }
                    delete needDeleteBuffer;
                    needDeleteBuffer = NULL;
                }
                else  //Copy delete
                {
                    BinNode<T> *needConverNode = iter;
                    preIter = iter;
                    iter = iter->left;          //turn left
                    while (NULL != iter->right)
                    {
                        preIter = iter;
                        iter = iter->right;
                    }
                    needConverNode->data = iter->data;
                    if (needConverNode == preIter)
                    {
                        preIter->left = iter->left;
                    }
                    else
                    {
                        preIter->right = iter->left;
                    }
                    delete iter;
                    iter = NULL;
                }
                treeNodeNum--;
                result = true;
                break;
            }
        }
        if (false == findOrNot)
        {
            result = false;
        }
    }
    return result;
}

测试代码如下：

    BinSearchTree<int, 100000> binSearchTree;
    int a[100000];
    srand(time(0));
    for (int i = 0; i < 100000; i++)
    {
        a[i] = rand();
    }

    for (int j = 0; j < 100; j++)
    {
        for (int i = 0; i < 100000; i++)
        {
            binSearchTree.insert(a[i]);
        }

        for (int i = 0; i < 100000; i++)
        {
            if (i % 2 == 0)
            {
                binSearchTree.delViaCopy(a[i]);
            }
            else
            {
                binSearchTree.delViaMerge(a[i]);
            }
        }
    }
luanzheng_365
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉查找树的基本操作：建立、查找、删除、插入（C++实现）
JunJie的个人博客
05-30 442
使用C++实现二叉查找树的基本操作接口
二叉搜索树的创建与删除！！！！！！(C++)
gangber的博客
03-29 188
#pragma once #include <iostream> #include <stack> template<class T> struct BSTNode { BSTNode(const T& val = T()) :val_(val), left_(nullptr), right_(nullptr) { } T val_; BSTNode<T>* left_; BSTNode<T>* right_; }
C++实现二叉排序树的创建、中序遍历与删除操作
weixin_44708784的博客
09-05 359
BinTree.h #pragma once #include<iostream> #include<vector> using namespace std; /* 二叉排序树,对二叉排序树进行中序遍历，可以得到一个递增的有序序列 */ template<class T> class BinNode { public: T key; BinNode* lchild, * rchild; }; template<class T> clas.
 二叉排序树c++代码及原理（插入、删除、查找、创建）
时间虚掷的孤岛
08-08 1947
二叉排序树 二叉排序树又称“二叉查找树”、“二叉搜索树”。 二叉排序树：或者是一棵空树，或者是具有下列性质的二叉树： 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3. 它的左、右子树也分别为二叉排序树。 二叉排序树通常采用二叉链表作为存储结构。中序遍历二叉排序树可得到一个依据关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即是对无序序列进行排序的过程。每次插入的.
二叉排序树的创建,查询,删除,遍历和插入（C++类实现）
jyx1572676601的博客
02-09 1038
视频教程推荐：懒猫老师-数据结构-(58)二叉排序树的删除(二叉查找树)_哔哩哔哩_bilibili 直接上代码，有简单注释。 #include<iostream> #include<array> #define DataType int using namespace std; struct BST_node { DataType data; BST_node *left; BST_node *right; }; class BST { private: BST_n
C++模板类二叉查找树的实现
05-12
在C++编程中，二叉查找树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有以下特性：对于任意节点，其左子树中的所有节点的值都小于该节点的值，右子树中所有节点的值都大于该节点的值。这种性质使得...
c++ 二叉查找树模板示例.pdf
06-02
在给定的C++代码中，定义了一个泛型的二叉查找树类`BinarySearchTree`，使用了模板类来支持不同类型的元素。以下是代码中的关键部分和它们对应的知识点： 1. **节点结构**：`BinarySearchTree`类中有一个私有嵌套...
VC/C++实现二叉搜索树查找算法
12-21
总结来说，VC/C++实现二叉搜索树查找算法涉及到理解二叉搜索树的性质，创建模板类来适应不同数据类型，以及编写递归查找函数。这种实现方式可以帮助我们高效地处理数据，特别是在频繁的查找、插入和删除操作中。同时...
精选_毕业设计_基于C++实现的二叉排序树_完整源码
03-05
二叉排序树（Binary Search Tree，BST），也称为二叉查找树或有序二叉树，是一种自平衡的二叉树数据结构。它在计算机科学中广泛应用于数据存储和检索，尤其是涉及快速查找、插入和删除操作的情况。在这个精选的毕业...
二叉查找树C++代码
05-10
在C++中实现二叉查找树，通常会使用模板类（template class）来实现泛型编程，允许存储任何数据类型。 以下是一个简单的C++二叉查找树模板类的实现概要： ```cpp template class BinarySearchTree { public: // ...
二叉查找树的查找、删除、插入等基本操作（C语言）
06-14
该源码使用C实现了最二叉查找树的基本操作，比如删除、查找，插入等。
二叉查找树的插入和删除详解
热门推荐
arui的专栏
08-14 1万+
二叉查找树是如下定义的： (1)  左子树不空，则左子树上的所有结点的值均小于根结点的值 (2)  右子树不空，则右子树上的所有结点的值均大于根结点的值 二叉查找树可以为空，二叉查找树是递归定义的，也就是说其左右子树也为二叉查找树。 二叉查找树是一种动态查找表，可以进行动态地插入和删除。前面的定义中我们假定二叉查找树不含有相同元素。 由定义可知二叉查找树的中序序列为一个递增序列 常见的
二叉搜索树插入、查找、删除模板
weixin_30271335的博客
03-16 56
#include<cstdio> using namespace std; typedef struct node; typedef node * tree; struct node { int data; tree lchild,rchild; }; void insert(tree &bt,int n) { if(bt)...
C++模板实现二叉查找树(三 深度优先遍历)
luanzheng_365的博客
03-31 393
二叉树的深度优先遍历有以下三种模式: 1. 先序遍历(VLR) – 此模式为先访问父节点,再访问左节点,最后访问右节点. 2. 中序遍历(LVR) – 此模式为先访问左节点,再访问父节点,最后访问右节点. 按照中序遍历方法访问二叉查找树,得到的结果是从小到大排列有序的. 3. 后序遍历(LRV) – 此模式为先访问左节点,再访问右节点,最后访问父节点.遍历的思想有两种: 递归 非递归:
450.删除二叉搜索树中的节点
zrh_CSDN的博客
11-18 444
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。 一般来说，删除节点可分为两个步骤： 首先找到需要删除的节点； 如果找到了，删除它。 说明： 要求算法时间复杂度为 O(h)，h 为树的高度。 示例: root = [5,3,6,2,4,null,7] key = 3...
【C++】二叉搜索树模拟实现（两种方法删除节点）
m0_62572672的博客
11-05 778
4.二叉树的删除（方法二：较为推荐）用引用结合递归的方式，具体逻辑没有变化，不过用引用简化了处理指针指向的问题，唯一注意的一点是在交换值之后递归的时候不能直接从根节点开始找。需要手动给出要删除节点所在子树的根节点，不然是找不到的。
二叉搜索树：BST模板类、查找、插入、删除操作 (C++)
amoscykl的博客
08-11 2504
二叉搜索树   1.顺序性 任一节点r的左(右)子树，所有节点均不大于（小于）r   2.中序遍历序列 对二叉搜索树做一次中序遍历，即可将该树转换为一个线性序列，且该序列中的节点严格按照其大小次序排列。 任何一棵二叉树是二叉搜索树,当且仅当其中序遍历序列单调非降   3.BST模板类 二叉搜索树属于二叉树的特例，故自然可以基于BinTree模板类 #include ...
二叉树介绍与代码实现
夜飘凌的博客
09-13 373
#include<stdio.h> #include<stdlib.h> typedef char ElemType; typedef struct Node{ ElemType data; struct Node *lchild,*rchild; }BTNode,*BTree; BTree CreatTree() { int i,j,in;char ch; BTree T=NULL,s[50],q; printf("Please Enter NO,Value:"); s
动态查找之二叉查找树（查找） c++实现
hopegrace的博客
07-16 1002
算法思想 二叉搜索树（又称二叉查找树或二叉排序树）BST树 二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； ...
c++统计二叉搜索树的节点数
最新发布
12-04
以下是C++统计二叉搜索树节点数的代码实现： ```c++ #include using namespace std; // 定义二叉搜索树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值