二叉排序树类

最新推荐文章于 2022-04-01 16:49:42 发布
最新推荐文章于 2022-04-01 16:49:42 发布
阅读量235 收藏
点赞数
分类专栏： 数据结构 文章标签： 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 636
根据《算法导论》实现的二叉排序树 #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 156
#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 2690
参考了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 3835
折半查找树也叫做二叉排序树。所谓的折半查找树就是左子树的所有节点都比跟节点小，右子树的所有节点都比根节点大（不考虑有重复元素的情况）。 上图就是一颗典型的排序二叉树。它是平衡排序二叉树（AVL）的基础。 可以很容易的看出来，上图的dfs序就是从小到大排好序的。 以下内容来自数据结构与STL。 BinSearchTree类的字段如下： #ifndef _BIN_SEARCH_TREE_
二叉排序树（二叉查找树、二叉搜索树）
热门推荐
rodman177的博客
05-03 10万+
什么是二叉查找树： 根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值，这一规则适用于二叉查找树中的每一个节点。 本文章重点来讨论一下关于二叉查找树删除节点的问题。 有一下二叉查找树，如图： 在删除节点的时候我们只需考虑一下三种情况： （1）要删除的节点是叶子结点，如图： （2）要删除的节点有左节点但是没有右节点，或者有右节点但是没有左节点，如图： （3）要删除的节点既有...
二叉排序树的C++实现
championlee_cs的专栏
06-10 9240
最近复习了一下C++语言，复习的过程中顺带重温了下数据结构的一些内容，一石二鸟呀！下面是类模板实现二叉排序树。     先定义节点类型和二叉树类型： template class BinaryTree; template //节点类的定义 class Node {private: Node*lchild, *rchild; T info; public: Node()
二叉排序树的理解和实现(Java)
如是说的博客
03-12 9046
二叉排序树的定义和性质 二叉排序树又称二叉排序树。它或者是一个空树，或者是一个具有下列性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于它的根结构的值 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值 它的左、右子树也分别是二叉排序树 如下图是一个二叉排序树： 下面的代码(Java实现)基本全部基于递归实现(非递归操作复杂且效率高)，简单的实现了BST的这些操作：初始...
通过c++设计二叉排序树类（BSTree），实现插入结点、构造二叉排序树、输出查找路径、判断是否二叉排序树，4个成员函数。
最新发布
05-22
好的，下面是代码实现： ```cpp #include <iostream> using namespace std; // 二叉排序树结点类 class BSTNode { public: int data; BSTNode *left; BSTNode *right; BSTNode(int val) { data = val; left = right = NULL; } }; // 二叉排序树类 class BSTree { private: BSTNode *root; // 辅助函数：插入结点 void insertNode(int val, BSTNode *&node) { if (node == NULL) { node = new BSTNode(val); } else if (val < node->data) { insertNode(val, node->left); } else if (val > node->data) { insertNode(val, node->right); } } // 辅助函数：构造二叉排序树 void createBSTree(int arr[], int len) { for (int i = 0; i < len; i++) { insertNode(arr[i], root); } } // 辅助函数：输出查找路径 bool searchPath(int val, BSTNode *node) { if (node == NULL) { return false; } else if (val == node->data) { cout << node->data << endl; return true; } else if (val < node->data) { cout << node->data << " "; return searchPath(val, node->left); } else if (val > node->data) { cout << node->data << " "; return searchPath(val, node->right); } } // 辅助函数：判断是否二叉排序树 bool isBSTree(BSTNode *node, int min_val, int max_val) { if (node == NULL) { return true; } if (node->data < min_val || node->data > max_val) { return false; } return isBSTree(node->left, min_val, node->data - 1) && isBSTree(node->right, node->data + 1, max_val); } public: BSTree() { root = NULL; } // 插入结点 void insert(int val) { insertNode(val, root); } // 构造二叉排序树 void create(int arr[], int len) { createBSTree(arr, len); } // 输出查找路径 void search(int val) { bool found = searchPath(val, root); if (!found) { cout << "Not found!" << endl; } } // 判断是否二叉排序树 bool isBST() { return isBSTree(root, INT_MIN, INT_MAX); } }; int main() { int arr[] = { 50, 30, 70, 20, 40, 60, 80 }; int len = sizeof(arr) / sizeof(arr[0]); BSTree bst; bst.create(arr, len); int val1 = 40; bst.search(val1); int val2 = 90; bst.search(val2); bool isBST = bst.isBST(); cout << "Is a binary search tree: " << isBST << endl; return 0; } ``` 这里使用了递归实现插入结点、构造二叉排序树、输出查找路径、判断是否二叉排序树这四个成员函数。其中，构造二叉排序树函数接受一个整型数组和数组长度，通过循环调用插入结点函数来构造二叉排序树。输出查找路径函数会输出查找到的结点以及经过的路径，如果没找到则输出 "Not found!"。判断是否二叉排序树函数使用了限制最大值和最小值的方法来确保每个结点都符合二叉排序树的定义。 在主函数中，我们创建了一个整型数组并调用了 BSTree 类的成员函数来操作二叉排序树，最后输出是否是二叉排序树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值