二叉排序树类

最新推荐文章于 2022-04-01 16:49:42 发布
最新推荐文章于 2022-04-01 16:49:42 发布
阅读量236 收藏
点赞数
分类专栏： 数据结构 文章标签： c++ 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Gxysbra/article/details/107762763
版权

二叉排序树

代码

#include <iostream>

using namespace std;

// 节点类
template <typename T>
struct Node
{
    T data;
    Node<T> *left;
    Node<T> *right;
    Node<T> *parent;
    Node() : left(nullptr), right(nullptr), parent(nullptr) {}
    Node(const T &value) : data(value), left(nullptr), right(nullptr), parent(nullptr) {}
};

// 节点类工厂函数
template <typename T>
Node<T>* create_node(const T &data)
{
    Node<T> *pNode = new Node<T>(data);
    return pNode;
}

// 二叉树类
template <typename T>
class BinarySortTree
{
private:
    Node<T> *m_pRoot;

public:
    BinarySortTree()
        : m_pRoot(nullptr) {}

    ~BinarySortTree()
    {
        destroy(m_pRoot);
    }

    bool isEmpty() const
    {
        return (m_pRoot == nullptr);
    }
    
    // 利用循环进行数据插入
    void insert(const T &data)
    {
        Node<T> *pNode = create_node(data);
        if (m_pRoot == nullptr)
        {
            m_pRoot = pNode;
        }
        else
        {
            Node<T> *pCur = m_pRoot;
            Node<T> *pPre = nullptr;
            while (pCur != nullptr)
            {
                pPre = pCur;
                if (data < pCur->data)
                {
                    pCur = pCur->left;
                }
                else if (data > pCur->data)
                {
                    pCur = pCur->right;
                }
                else
                {
                    delete pNode;
                    return;
                }
            }
            if (data < pPre->data)
            {
                pPre->left = pNode;
            }
            else
            {
                pPre->right = pNode;
            }
            pNode->parent = pPre;
        }
    }

    // 利用递归进行数据插入
    void insertByRecur(const T &data)
    {
        if (m_pRoot == nullptr)
        {
            Node<T> *pNode = create_node(data);
            m_pRoot = pNode;
        }
        else
        {
            // 调用private递归插入函数
            insert(m_pRoot, data);
        }
    }

    // 查找数据为data的节点，如果不存在则返回空指针
    Node<T>* find(const T &data)
    {
        Node<T> *pCur = m_pRoot;
        while (pCur != nullptr)
        {
            if (data < pCur->data)
            {
                pCur = pCur->left;
            }
            else if (data > pCur->data)
            {
                pCur = pCur->right;
            }
            else
            {
                break;
            }
        }
        return pCur;
    }

    // 删除值为data的节点所在的子树
    void deleteSubTree(const T &data)
    {
        Node<T> *pNode = find(data);
        if (pNode != nullptr)
        {
            // 调用private成员函数
            deleteSubTree(pNode);
        }
    }

    // 删除值为data的节点
    void deleteNode(const T &data)
    {
        Node<T> *pNode = find(data);
        if (pNode != nullptr)
        {
            // 调用private成员函数
            deleteNodeImpl(pNode);
        }      
    }

    void print() const
    {
        // 调用private成员函数
        print(m_pRoot);
        cout << endl;
    }

private:
    // 销毁二叉排序树
    static void destroy(Node<T> *pRoot)
    {
        if (pRoot == nullptr)
            return;
        destroy(pRoot->left);
        destroy(pRoot->right);
        delete pRoot;
        pRoot = nullptr;        
    }

    // 递归插入
    static void insert(Node<T> *pRoot, const T &data)
    {
        if (data < pRoot->data)
        {
            if (pRoot->left == nullptr)
            {
                Node<T> *pNode = create_node(data);
                pRoot->left = pNode;
                pNode->parent = pRoot;
            }
            else
            {
                insert(pRoot->left, data);
            }
        }
        else if (data > pRoot->data)
        {
            if (pRoot->right == nullptr)
            {
                Node<T> *pNode = create_node(data);
                pRoot->right = pNode;
                pNode->parent = pRoot;
            }
            else
            {
                insert(pRoot->right, data);
            }
        }
        else
        {
            return;
        }
    }

    // 递归删除子树
    void deleteSubTree(Node<T> *pRoot)
    {
        if (pRoot->left != nullptr)
            deleteSubTree(pRoot->left);
        if (pRoot->right != nullptr)
            deleteSubTree(pRoot->right);
        if (pRoot->parent == nullptr)
        {
            delete pRoot;
            m_pRoot = nullptr;
            return;
        }
        if (pRoot->data < pRoot->parent->data)
            pRoot->parent->left = nullptr;
        else
            pRoot->parent->right = nullptr;
        delete pRoot;        
    }

    // 分四种情况删除节点
    void deleteNodeImpl(Node<T> *pNode)
    {
        if ((pNode->left == nullptr) && (pNode->right == nullptr))
            deleteLeafNode(pNode); 
        else if ((pNode->left != nullptr) && (pNode->right == nullptr))
            deleteNodeHasLeft(pNode);
        else if ((pNode->left == nullptr) && (pNode->right != nullptr))
            deleteNodeHasRight(pNode);
        else
            deleteNodeHasBoth(pNode);
    }

    // 删除的节点为叶节点
    void deleteLeafNode(Node<T> *pNode)
    {
        if (pNode->parent == nullptr)
        {
            m_pRoot = nullptr;
        }    
        else
        {
            if (pNode->data < pNode->parent->data)
                pNode->parent->left = nullptr;
            else if (pNode->data > pNode->parent->data)
                pNode->parent->right = nullptr;
        }
        delete pNode;
    }

    // 删除的节点只有左子树
    void deleteNodeHasLeft(Node<T> *pNode)
    {
        if (pNode->parent == nullptr)
        {
            m_pRoot = pNode->left;
            m_pRoot->parent = nullptr;      
        }
        else
        {
            pNode->left->parent = pNode->parent;
            if (pNode->data < pNode->parent->data)
                pNode->parent->left = pNode->left;               
            else if (pNode->data > pNode->parent->data)
                pNode->parent->right = pNode->left;
        }
        delete pNode;
    }

    // 删除的节点只有右子树
    void deleteNodeHasRight(Node<T> *pNode)
    {
        if (pNode->parent == nullptr)
        {
            m_pRoot = pNode->right;
            m_pRoot->parent = nullptr;
            delete pNode;
        }
        else
        {
            pNode->right->parent = pNode->parent;
            if (pNode->data < pNode->parent->data)
                pNode->parent->left = pNode->right;               
            else if (pNode->data > pNode->parent->data)
                pNode->parent->right = pNode->right;
        }
        delete pNode;
    }

    // 删除的节点左右子树都存在
    void deleteNodeHasBoth(Node<T> *pNode)
    {
        Node<T> *pCur = pNode->left;
        Node<T> *pPre = nullptr;
        while (pCur != nullptr)
        {
            pPre = pCur;
            pCur = pCur->right;
        }
        T backup = pPre->data;
        deleteNodeImpl(pPre);
        pNode->data = backup;
    }

    // 中序遍历打印二叉树
    static void print(Node<T> *pRoot)
    {
        if (pRoot == nullptr)
            return;
        print(pRoot->left);
        cout << pRoot->data << " ";
        print(pRoot->right);        
    }
};

int main()
{
    BinarySortTree<int> sortTree;
    cout << "is the tree empty: " << sortTree.isEmpty() << endl;
    sortTree.insert(32);
    sortTree.insert(45);
    sortTree.insert(16);
    sortTree.insert(7);
    sortTree.insert(28);
    sortTree.insert(40);
    cout << "is the tree empty after inserting: " << sortTree.isEmpty() << endl;
    sortTree.print();
    sortTree.insertByRecur(30);
    sortTree.insertByRecur(19);
    sortTree.insertByRecur(7);
    sortTree.insertByRecur(56);
    sortTree.insertByRecur(43);
    sortTree.insertByRecur(78);
    cout << "is the tree empty after inserting: " << sortTree.isEmpty() << endl;
    sortTree.print();
    auto pNode = sortTree.find(40);
    cout << "is there 40: " << ((pNode == nullptr) ? "no" : "yes") << endl;
    pNode = sortTree.find(31);
    cout << "is there 31: " << ((pNode == nullptr) ? "no" : "yes") << endl;
    sortTree.deleteNode(28);
    cout << "after deleting 28, the tree is: " << endl;
    sortTree.print();
    sortTree.deleteNode(31);
    cout << "after deleting 31, the tree is: " << endl;
    sortTree.print();
    sortTree.deleteSubTree(45);
    cout << "after deleting subtree 45, the tree is: " << endl;
    sortTree.print();
    sortTree.deleteNode(32);
    cout << "after deleting root 35, the tree is: " << endl;
    sortTree.print();
    sortTree.deleteSubTree(16);
    cout << "after deleting subtree root 16, the tree is: " << endl;
    cout << (sortTree.isEmpty() ? "empty" : "has elem") << endl;
    return 0;
}

测试结果

在这里插入图片描述

Gxysbra
关注
专栏目录
二叉排序树
02-07
输入二叉树信息建立二叉树，用四种方法遍历该二叉树，求该二叉树的结点个数和高度，求某结点的父结点
排序二叉树类
Da_Xia1的博客
11-25 182
package tree; /** *排序二叉树类 * 二叉树不允许有重复的数据 */ public class Tree<E extends Comparable<E>> { //用于存放根节点的引用 private Node root; /** * Node类用于描述二叉树当中的某个节点 * 其中,data用于存放数据(即元素),left和 * right用于存放其左右子树的引用 */ class N
二叉排序树（模板类）
ly_chg的专栏
08-09 638
根据《算法导论》实现的二叉排序树 #include <iostream> template<typename KeyType> class TreeNode { typedef KeyType _KeyType; typedef TreeNode* _NodePtr; typedef TreeNode& _NodeRef; public: TreeNode() { _left = NULL; _right = NU
二叉排序树类的： C++ 实现
weixin_30471065的博客
05-22 157
#include<iostream> using namespace std; template<class T> struct TreeNode { T element; TreeNode<T>*parent, *lnode, *rnode; TreeNode(){ parent = lnode = rnode =...
C++实现二叉搜索树（二叉排序树）模板类
FS's Home
12-09 2695
参考了Weiss的数据结构与算法分析C++描述第三版完成二叉搜索树
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
在实际编程中，二叉排序树的结构通常用类来表示，包含节点的值、左子节点和右子节点的引用。此外，还需要提供插入、查找和遍历等方法。在给定的压缩文件"二叉排序树_17281183_刘梦婷"中，可能包含了实现这些功能的...
实现二叉排序树的各种算法
07-25
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在处理搜索、插入和删除操作时具有较高的效率。二叉排序树的主要特性是：对于任意节点，其左子树中的所有...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
二叉排序树详解
云杉木屋
04-01 2万+
摘要：本篇笔记专门介绍二叉排序树，重点讲解了二叉排序树的特性，以及二叉排序树各方面的基本实现。
数据结构-二叉排序树（图文详细版）
淡沫初夏zz的博客
01-17 6万+
二叉排序树
二叉排序树Binary sort tree（BST）
xiaobai_hellow的博客
03-06 1万+
二叉搜索树（BST）1.二叉搜索树的概念2.二叉搜索树的操作及应用3.二叉搜索树的模拟实现 1.二叉搜索树的概念 二叉排序数也叫二叉搜索树，有以下特点： ①：二叉搜索树的左节点永远小于父节点。 ②：二叉搜索树的右节点永远大于父节点。 ③：它的左右子树也分别为二叉搜索树 2.二叉搜索树的操作及应用 二叉搜索树本质还是二叉树，只是对节点各种需求有了不同的方式。 1.名字叫二叉搜索树，那么其查找方式肯定很棒 由于它的特点，当树不为空的时候，我们只需要去比较要搜索的值与各个节点的值，如果大于该节点，那么就在该节点的
二叉排序树（折半查找树）模板类实现
BeingLucky的博客
01-29 3840
折半查找树也叫做二叉排序树。所谓的折半查找树就是左子树的所有节点都比跟节点小，右子树的所有节点都比根节点大（不考虑有重复元素的情况）。 上图就是一颗典型的排序二叉树。它是平衡排序二叉树（AVL）的基础。 可以很容易的看出来，上图的dfs序就是从小到大排好序的。 以下内容来自数据结构与STL。 BinSearchTree类的字段如下： #ifndef _BIN_SEARCH_TREE_
二叉排序树（二叉查找树、二叉搜索树）
热门推荐
rodman177的博客
05-03 10万+
什么是二叉查找树： 根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值，这一规则适用于二叉查找树中的每一个节点。 本文章重点来讨论一下关于二叉查找树删除节点的问题。 有一下二叉查找树，如图： 在删除节点的时候我们只需考虑一下三种情况： （1）要删除的节点是叶子结点，如图： （2）要删除的节点有左节点但是没有右节点，或者有右节点但是没有左节点，如图： （3）要删除的节点既有...
二叉排序树的C++实现
championlee_cs的专栏
06-10 9241
最近复习了一下C++语言，复习的过程中顺带重温了下数据结构的一些内容，一石二鸟呀！下面是类模板实现二叉排序树。     先定义节点类型和二叉树类型： template class BinaryTree; template //节点类的定义 class Node {private: Node*lchild, *rchild; T info; public: Node()
二叉排序树的理解和实现(Java)
如是说的博客
03-12 9050
二叉排序树的定义和性质 二叉排序树又称二叉排序树。它或者是一个空树，或者是一个具有下列性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于它的根结构的值 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值 它的左、右子树也分别是二叉排序树 如下图是一个二叉排序树： 下面的代码(Java实现)基本全部基于递归实现(非递归操作复杂且效率高)，简单的实现了BST的这些操作：初始...
通过c++设计二叉排序树类（BSTree），实现插入结点、构造二叉排序树、输出查找路径、判断是否二叉排序树，4个成员函数。
最新发布
05-22
// 二叉排序树类 class BSTree { private: BSTNode *root; // 辅助函数：插入结点 void insertNode(int val, BSTNode *&node) { if (node == NULL) { node = new BSTNode(val); } else if (val < node->data)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值