二叉搜索树的c++类模板封装实现

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

二叉搜索树：一个近似二分搜索的数据结构跳表有点像，平衡二叉树可以靠旋转操作维护自平衡性，解决退化为链表问题；跳表通过随机函数进行上层节点增删，统计意义上维护平衡性。

c++实现代码：

Binary_SearchTree.h

hpp文件 实现类的成员函数

测试文件

测试运行结果

缺点：

概念：

二叉搜索树：二叉搜索树是由二叉树来组织的，树中每一个子树的根节点key值都大于左树的key值而小于右子树的key值。

                   二叉搜索树的中序遍历key值恰好是从小到达排序。查询二叉树、MinMum、MaxMum、Insert和delete等操作时间复杂                    度为O(h); h为树的高度log2(n);

c++实现代码：

              头文件，树节点和树 类的定义

Binary_SearchTree.h

   

#ifndef _BINARY_SEARCHTREE
#define  _BINARY_SEARCHTREE

template<typename T>//定义Element类，便于外部调用函数更改数据类型
class Element
{
public:
	T key;//便于在节点中随时加入数据
	char name;

};

template<typename T> class BST;//BST模板类的声明

template<typename T>
class BSTNode
{
	friend class BST<T>;//友元类声明 BST二叉树要访问节点私有元素
public:
	Element<T> getElement();
	private:
		Element<T> data;
	    BSTNode *leftChild;
	    BSTNode *rightChild;
		void display(int i);//递归展示当前节点信息
	
};

template<typename T>//搜索二叉树模板类
class BST
{
public:
	BST(BSTNode<T>*init = 0);
	bool BST_insert(const Element<T> &node);//插入元素
	BSTNode<T>* BST_Search(const Element<T>&node);//递归搜索
	BSTNode<T>* BST_Search(BSTNode<T>*,const Element<T>&);

	BSTNode<T>*BST_Search_Iterator(const Element<T>&);//迭代搜索
	bool Delete_Node(const Element<T>&node);//删除节点
	BSTNode<T>*MinMum();//树的key最大节点
	BSTNode<T>*MaxMum();//树的key最小节点

	void midOrder();//中序遍历
	void midOrder(BSTNode<T>*root);

	void display();//递归左右子树展示当前树所有节点信息
	~BST();

private:
	BSTNode<T> *root;

};

#endif

hpp文件 实现类的成员函数

#include"Binary_SearchTree.h"
#include"iostream"
using namespace std;
//节点的成员函数

//节点内容获取
template<typename T>
void BSTNode<T>::display(int i)
{
	cout << "position: " << i << "  data.Key：" << data.key << " value：" << data.name << endl;
	if (leftChild)
		leftChild->display(2 * i);
	if (rightChild)
		rightChild->display(2 * i + 1);
}
//获取节点Element
template<typename T>
Element<T> BSTNode<T>::getElement()
{
	return data;
}


//树的成员函数

//构造初始化
	template<typename T>
	BST<T>::BST(BSTNode<T>*init = NULL)
	{
		root = init;
	}
//插入节点 
	template<typename T>
	bool BST<T>::BST_insert(const Element<T> &node)
	{
		BSTNode<T>*p = NULL;
		BSTNode<T>*q = root;
		while (q)//查找插入位置 最终肯定为叶子
		{
			p = q;
			if (node.key == q->data.key)
			{
				return false;
			}
			if (node.key > q->data.key)
			{
				q = q->rightChild;
			}
			else
			{
				q = q->leftChild;
			}
		}
        //创建新节点保存插入元素
		q = new BSTNode<T>;
		q->data = node;//Element数据类型浅拷贝，若Element包含指针元素得重载=操作符
		q->leftChild = NULL;
		q->rightChild = NULL;
        //空树的情况
		if (root == NULL)
		{
			root = q;
		}
		else
		{
			if (p->data.key > q->data.key)
			{
				p->leftChild = q;
			}
			else
			{
				p->rightChild = q;
			}
		}
		return true;
	}


//点展示树左右子树
//根据节点递归显示左右子树

	template<typename T>
	void BST<T>::display()
	{
		if (root == NULL)
		{
			cout << "树为空" << endl;
		}
		else
		{
			root->display(1);
		}
	}

	//查找节点 递归方法 
	//递归的部分需要传入根节点（BSTNode）
	//外部以Element类型加载数据，故写两个函数，改为一个Element端口
	template<typename T>
	BSTNode<T>*BST<T>::BST_Search(const Element<T>&node)
	{
		return BST_Search(root, node);
	}

	template<typename T>
	BSTNode<T>*BST<T>::BST_Search(BSTNode<T>*b, const Element<T>&node)
	{
		if (b == NULL)
		{
			return NULL;
		}
		if (node.key == b->data.key)
		{
			return b;
		}
		else if (node.key < b->data.key)
		{
			return BST_Search(b->leftChild, node);
		}
		else
		{
			return BST_Search(b->rightChild, node);
		}
	}
	
	//非递归查找 迭代方式实际中对大多数计算机更有效
	template<typename T>
	BSTNode<T>*BST<T>::BST_Search_Iterator(const Element<T>&node)
	{
		BSTNode<T>*t = root;
		while (t)
		{
			if (node.key == t->data.key)
			{
				return t;
			}
			else if (node.key < t->data.key)
			{
				t = t->leftChild;
			}
			else
			{
				t = t->rightChild;
			}
		}
	}

	//删除节点
	template<typename T>
	bool BST<T>::Delete_Node(const Element<T>&node)
	{
		if (root == NULL)
		{
			cout << "root == NULL" << endl;
			return 0;
		}
		BSTNode<T> *del = NULL;
		BSTNode<T> *pcurr = root;
		BSTNode<T> *parent = NULL;
		while (pcurr != NULL && pcurr->data.key != node.key)//先找到
		{
			if (node.key < pcurr->data.key)
			{
				parent = pcurr;
				pcurr = pcurr->leftChild;
			}
			if (node.key > pcurr->data.key)
			{
				parent = pcurr;
				pcurr = pcurr->rightChild;
			}
		}
		if (pcurr == NULL)//找了一遍没找到
		{
			return false;
		}
		if (pcurr->leftChild == NULL)//只有右孩子
		{
			if (pcurr == root)//如果是根节点 则根节点移动到右孩子即可
				root = root->rightChild;
			else if (pcurr == parent->leftChild)//若待删节点是parent左孩子
			{
				parent->leftChild = pcurr->rightChild;
			}
			else if (pcurr == parent->rightChild)//若待删除节点是parent右孩子
			{
				parent->rightChild = pcurr->rightChild;
			}
			del = pcurr;
		}
		else if (pcurr->rightChild == NULL)//只有左孩子
		{
			if (pcurr == root)
				root = root->leftChild;
			else if (pcurr == parent->leftChild)
			{
				parent->leftChild = pcurr->leftChild;
			}
			else
			{
				parent->rightChild = pcurr->leftChild;
			}
			del = pcurr;
		}
		else//既有左孩子又有右孩子 找到右子树最小（最左）的元素替换，在按照以上方式删除
		{
			//找到最左边的节点
			BSTNode<T> *left = pcurr->rightChild;
			parent = pcurr;
			while (left->leftChild)
			{
				parent = left;
				left = left->leftChild;
			}
			del = left;
			pcurr->data.key = left->data.key;//交换节点的值
			if (parent->leftChild == left)
			{
				parent->leftChild = left->rightChild;
			}
			else//当pcurr只有一个右节点时，left是parent的右子树
			{
				parent->rightChild = left->rightChild;
			}
		}
		delete del;
	}


	//中序遍历
	template<typename T>
	void BST<T>::midOrder()
	{
		midOrder(root);
	}
	template<typename T>
	void BST<T>::midOrder(BSTNode<T>*root)
	{
		if (root == NULL)
		{
			return;
		}
		midOrder(root->leftChild);
		cout<<root->getElement().key<<" "<<root->getElement().name<<"\t";
		midOrder(root->rightChild);
	}

	//返回树中最小的节点
	template<typename T>
	BSTNode<T>*	BST<T>::MinMum()
	{
		BSTNode<T>*tmp = root;
		while (tmp->leftChild)
		{
			tmp = tmp->leftChild;
		}
		return tmp;
	}

	//返回树种最大的节点
	template<typename T>
	BSTNode<T>*	BST<T>::MaxMum()
	{
		BSTNode<T>*tmp = root;
		while (tmp->rightChild)
		{
			tmp = tmp->rightChild;
		}
		return tmp;
	}

template<typename T>
	BST<T>::~BST()
	{
		delTree(root);
	}
	template<typename T>
	void BST<T>::delTree(BSTNode<T>*root)
	{
		BSTNode<T>*tmpLeft = NULL;
		BSTNode<T>*tmpRight = NULL;
		while (root)
		{
			tmpLeft = root->leftChild;
			tmpRight = root->rightChild;
			delete root;
			delTree(tmpLeft);
			delTree(tmpRight);
		}
	}

测试文件

#include"dm_04_BST.hpp"
#include"iostream"
#include"cmath"
using namespace std;

void main()
{
	Element<int> a,b,c,d,e,f,g,h;
	BST<int> tree;
	a.key = 5; a.name = 'a'; cout << tree.BST_insert(a) << endl;
	b.key = 2; b.name = 'b'; cout << tree.BST_insert(b) << endl;
	c.key = 7; c.name = 'c'; cout << tree.BST_insert(c) << endl;
	d.key = 1; d.name = 'd'; cout << tree.BST_insert(d) << endl;
	e.key = 6; e.name = 'e'; cout << tree.BST_insert(e) << endl;
	f.key = 8; f.name = 'f'; cout << tree.BST_insert(f) << endl;
	g.key = 4; g.name = 'g'; cout << tree.BST_insert(g) << endl;
	h.key = 0; h.name = 'h'; cout << tree.BST_insert(h) << endl;
	//打印二叉树,从根节点开始，递归打印左右	
	tree.display();

	cout << "递归搜索Key" << endl;
	cout<<tree.BST_Search(e)->getElement().key<<endl;

	cout << "迭代搜索Key" << endl;
	cout << tree.BST_Search_Iterator(e)->getElement().key<<endl;

	cout << "搜索二叉树中序遍历恰好是从小到大" << endl;
	tree.midOrder();

	cout << "二叉搜索树中键值最大的" << endl;
	Element<int> max = tree.MaxMum()->getElement();
	cout << "key: " << max.key << " name: " << max.name << endl;
	cout << "二叉搜索树中键值最小的" << endl;
	Element<int> min = tree.MinMum()->getElement();
	cout << "key: " << min.key << " name: " << min.name << endl;

	cout <<endl<< "删除节点d" << endl;
	tree.Delete_Node(d);
	tree.midOrder();
	cout << endl;
	system("pause");
}

 

测试运行结果

缺点：

二叉搜索树，在一定条件下会退化为链表，失去二叉搜索树的优点，构建二叉搜索树应当随机构建二叉搜索树，n个节点n!中排序，每一种排序等概。

平衡二叉树红黑树可以解决这个问题，有时间在努力封装一下红黑树吧。

有些颓废，希望自己能珍惜时间。

进击ing小白
关注
专栏目录
【C++】二叉搜索树
knous
07-27 350
二叉搜索树及模拟实现，后续更新练习题
STL源码笔记（17）—二叉排序树BST（C++封装）
上善若水
05-18 5432
STL 二叉排序树的C++实现
二叉树的类封装（C++）
01-18
利用C++语言封装了二叉树的数组实现及链表实现，常用操作均被封装到类中。如：检索，添加、删除、遍历（前序、中序、后序）等。
【JS数据结构与算法】二叉搜索树的封装
29的博客
08-18 218
采用链式存储结构封装搜索二叉树 思想： 由二叉树的定义可知，二叉树的结点由一个数据元素和分别指向左、右结点的两个分支构成，所以表示二叉树的链表中的结点至少要包含三个域。 data：数据域。 lchild：左指针域。 rchild：右指针域。 封装二叉搜索树代码 function BinarySearchTree(){ // 新结点创建的构造函数 func...
二叉排序树实现（C++封装）
weixin_33816821的博客
01-08 88
一天一个算法，边回想算法细节，边捡回C++，试验性程序，留作记念。 设计思路 设计一个类，根结点只可读取，具备构造二叉树、插入结点、删除结点、查找、 查找最大值、查找最小值、查找指定结点的前驱和后继等功能接口。 二叉排序树概念 它或者是一棵空树；或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结...
基于C++的二叉树实现
07-29
实现函数包括： public: BinaryTree(); ~BinaryTree(); BinaryTree(ElemType e);//已元素e为根建立树 BinaryTree(const BinaryTree<ElemType>& copy);//拷贝构造函数 BinaryTree(BinTreeNode<ElemType>* r);//以r为根建立树 BinTreeNode<ElemType>* GetRoot() const; bool Empty() const; bool GetElem(BinTreeNode<ElemType>* cur, ElemType& e) const; bool SetElem(BinTreeNode<ElemType>* cur, ElemType& e); void PreOrder(void(*visit)(const ElemType& e)) const; void InOrder(void(*visit)(const ElemType& e)) const; void PostOrder(void(*visit)(const ElemType& e)) const; void LevelOrder(void(*visit)(const ElemType& e)) const; int NodeCount() const; BinTreeNode<ElemType>* GetLeftChild(const BinTreeNode<ElemType>* cur) const; BinTreeNode<ElemType>* GetRightChild(const BinTreeNode<ElemType>* cur) const; BinTreeNode<ElemType>* GetParent(const BinTreeNode<ElemType>* cur) const; void InsertLeftChild(BinTreeNode<ElemType>* cur, ElemType& e); void InsertRightChild(BinTreeNode<ElemType>* cur, ElemType& e); void DeleteLeftChild(BinTreeNode<ElemType>* cur); void DeleteRightChild(BinTreeNode<ElemType>* cur); int Height();
二叉搜索树的封装
weixin_42572968的博客
03-25 197
二叉搜索树的封装 二叉搜索树有四个最基本的属性：指向节点的根（root），节点中的键（key）、左指针（right）、右指针（right）。 所以，二叉搜索树中除了定义 root 属性外，还应定义一个节点内部类，里面包含每个节点中的 left、right 和 key 三个属性。 // 节点类 class Node { constructor(key) { this.key = key; this.left = null; this.right = null; } } 二叉
二叉排序树模板类c++
02-03
本篇文章将详细介绍如何使用C++语言设计并实现一个二叉排序树模板类。 #### 二、二叉排序树模板类的设计与实现 ##### 2.1 模板类定义 在给定的部分代码中，首先定义了一个模板结构体`BiNode`用于表示二叉排序树中...
STL.rar_hash stl_stl 封装_搜索树
09-24
在STL中，搜索树主要通过`<set>`和`<map>`容器实现，它们基于红黑树这一自平衡二叉查找树。`<set>`用于存储唯一整数，而`<map>`则用于存储键值对，两者都支持快速的查找、插入和删除操作，其时间复杂度通常为O(log ...
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3174
红黑树详解
二叉树类构建，封装，各种遍历等功能集成cpp
11-23
1 定义二叉树类，封装构造二叉树操作、遍历操作 2 实现由先序、中序序列构造二叉树的算法 3 实现由后序、中序序列构造二叉树的算法 4 各类递归 5 判定是否为完全二叉树
二叉查找树 c语言,二叉查找树(C语言实现)
weixin_33245968的博客
05-20 537
/** 构造一颗二叉查找树，实现树的插入、删除等基本操作**/#include#includetypedef struct node{int count; //记录某个元素出现的次数int data; //数据struct node * left;struct node * right;}Node,*PNode;int array[100]; //按序保存遍历后的元素int k=0; ...
面向对象案例：栈与队列的封装，二叉树
ANingL的博客
01-03 206
一.栈和队列的封装 1.栈 栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈）。 栈顶：允许进行操作的一端，栈底： 另一固定端，空栈： 当栈中没有元素时。 push: 向一个栈插入元素称为进栈； pop: 从一个栈删除元素称为是出栈。 栈的特点：后进先出（LIFO） 案例： class Stack(object): """ 根据列表的数据结构封装栈的数据结构 属...
二叉搜索树 c语言,二叉搜索树（C语言实现）
weixin_39823459的博客
05-23 341
数据结构typedef struct TreeNode {int data;//数据struct TreeNode* left;//左孩子struct TreeNode* right;//右孩子}BST, *BinTree;函数声明void Insert(BinTree& BST, int x);//插入元素void Delete(BinTree& BST, int x);//删除...
C语言-OJ-极简二叉搜索树(BST binary search tree)构建
Ouroboros的博客
06-18 312
问题描述 【定义】二叉搜索树(binary search tree)是二叉树的一种。 它可能是空的，也可能非空。 如果非空，则满足以下几条属性: (1) 每个结点(node)都有一个独一无二的整型键值(key) (2) 非空左子树的键值必须小于其根结点的键值 (3) 非空右子树的键值必须大于其根结点的键值 (4) 左右子树也均为二叉搜索树 输入格式 2行 第一行输入结点的总个数n(1<=n<=100) 第二行给出n个各不相同的整数（这些整数不会超过int类型的存储范围），这些整数被空格分隔。 输
二叉搜索树（BST数）——C语言实现
qq_27846147的博客
06-28 236
直接上代码 //BST树 #include <stdio.h> #include <stdlib.h> typedef int Elemtype; typedef struct LNode{ struct LNode *Lchild; struct LNode *Rchild; Elemtype data; }LNode; void create(LNode *l) { int key; scanf("%d",&key); l->data = key;
二叉搜索树（C语言实现）
weixin_46272577的博客
04-30 594
#include <iostream> #include <queue> #include <cstdio> #include <cstdlib> using namespace std; typedef struct TreeNode { int data;//数据 struct TreeNode* left;//左孩子 struct TreeNode* right;//右孩子 }BST, *BinTree; void Insert(Bin.
对二叉树的基本操作的类模板封装
John的专栏
07-05 1407
//‍BinaryTree.cpp //------------------------------------------------------------------------------------------------------------------------ // 对二叉树的基本操作的类模板封装 //------------------
C++数据结构与搜索算法详解：折半搜索与二叉查找树
动态搜索结构如二叉搜索树，通过动态调整以提升搜索效率，但增加了一些复杂性。选择哪种搜索结构取决于具体的应用场景和性能需求。 2. 折半搜索（Binary Search）: 折半搜索是基于有序列表进行的高效搜索算法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值