二叉排序树（搜索数）C++实现代码

最新推荐文章于 2023-07-24 19:55:20 发布
最新推荐文章于 2023-07-24 19:55:20 发布
阅读量257 收藏 1
点赞数 1
文章标签： 数据结构 c++ 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36147149/article/details/112295946
版权

自己用C++写的二叉排序树（搜索数），具有初始化、增、删、查、中序遍历的功能。由于二叉搜索树的中序遍历是一个升序的序列，这也是二叉搜索树的特征之一，而前序遍历和后续遍历意义不大，而且与中序遍历代码原理差不多，只需稍作改动，所以就没写后续遍历和前序遍历。不足之处还请大家多多指出

类头文件

#ifndef BinSearchTree_H
#define	BinSearchTree_H
#include <iostream>
using namespace std;

class BinNode
{

public:
	friend class BinTree;
	BinNode() {}
	BinNode(int data)
	{
		m_data = data;
		m_id = -1;
		m_parent = NULL;
		m_leftchild = NULL;
		m_rightchild = NULL;
	}
	bool insertNode(int data);		//插入数据为data的结点
	BinNode* getMaxNode();		//获取子树的最大结点
	BinNode* getMinNode();		//获取子树的最小结点
	BinNode* getPreNode();		//获取前驱结点，也即当前结点的左子树中最大的结点
	BinNode* getNextNode();		//获取后继结点，也即当前结点的右子树中的最小的结点
	bool deleteNode();		//删除当前结点
	BinNode* searchNode(int data);		//在子树中搜索数据为data的结点是否存在
	bool inOrderTraverse();			//中序遍历
	void clean();		//删除子树的所有结点
	int get_m_data() 
	{ 
		if (this != NULL)
			return m_data;
		else return -1;
	}
private:
	int m_data;
	BinNode* m_parent;
	BinNode* m_leftchild;
	BinNode* m_rightchild;
	int m_id;
};

class BinTree
{
public:
	BinTree()
	{
		size = 0;
		root = NULL;
	}
	~BinTree()
	{
		cout << "**********~BinTree()*******" << endl;
		cleanTree();
	}
	void insertTree(int* arry,int size);		//将序列中的size个数据插入到当前树中或者用该序列生成一棵二叉搜索树
	void insertTree(int data);		//插入数据为data的结点
	bool deleteTreeNode(int data);			//删除数据为data的结点
	BinNode* searchTree(int data);		//搜索树中数据为data的结点是否存在
	BinNode* getPreTreeNode(int data);	//获取数据为data的结点的前驱结点
	BinNode* getNextTreeNode(int data);	//获取数据为data的结点的后继结点
	BinNode* getTreeMaxNode();		//获取树的最大结点
	BinNode* getTreeMinNode();		//获取树的最小结点
	bool inOrderTree();				//中序遍历
	void cleanTree();		//清空树，将其变为一颗空树
private:
	BinNode* root;
	int size;   //树的所有结点个数
};
#endif

.cpp文件，类成员函数实现

#include <iostream>
#include "BinSearchTree.h"
using namespace std;

void BinTree::insertTree(int* arry,int size)	//使用初始序列构造一棵二叉搜索树
{
	int i = 0;
	if (root == NULL)
	{
		root = new BinNode;
		root->m_id = 0;
		root->m_data = *arry;
		root->m_parent = NULL;
		root->m_leftchild = NULL;
		root->m_rightchild = NULL;
		i++;
	}
	while(i<size)
	{
		root->insertNode(arry[i]);
		i++;
	}
}

void BinTree::insertTree(int data)
{
	if (root == NULL)
	{
		root = new BinNode;
		root->m_id = 0;
		root->m_data = data;
		root->m_parent = NULL;
		root->m_leftchild = NULL;
		root->m_rightchild = NULL;
	}
	else 
		root->insertNode(data);
}

bool BinTree::deleteTreeNode(int data)
{
	BinNode*  temp= this->searchTree(data);		//找到需要删除的结点
	if (temp != NULL)
	{
		temp->deleteNode();
		return true;
	}
	return false;
}

BinNode* BinTree::searchTree(int data)
{
	if (root == NULL)
		return NULL;
	else return root->searchNode(data);
}

bool BinTree::inOrderTree()
{
	if (root == NULL)
		return false;
	else
	{
		root->inOrderTraverse();
		cout << endl;
		return true;
	}
}

BinNode* BinTree::getPreTreeNode(int data)
{
	BinNode* temp = searchTree(data);
	if (temp == NULL)
		return NULL;
	else return temp->getPreNode();
}

BinNode* BinTree::getNextTreeNode(int data)
{
	BinNode* temp = searchTree(data);
	if (temp == NULL)
		return NULL;
	else return temp->getNextNode();
}

BinNode* BinTree::getTreeMaxNode()
{
	if (root != NULL)
		return root->getMaxNode();
	else return NULL;
}

BinNode* BinTree::getTreeMinNode()
{
	if (root != NULL)
		return root->getMinNode();
	else return NULL;
}

void BinTree::cleanTree()
{
	if (root == NULL)
		return;
	root->clean();
	root = NULL;
}


bool BinNode::insertNode(int data)
{
	if (data >= this->m_data)			//大的插入到右子树
	{
		if (this->m_rightchild == NULL)					//如果右孩子为空，则直接作为右孩子插入
		{
			this->m_rightchild = new BinNode;
			this->m_rightchild->m_parent = this;
			this->m_rightchild->m_data = data;
			this->m_rightchild->m_id = this->m_id * 2 + 2;
			this->m_rightchild->m_leftchild = NULL;
			this->m_rightchild->m_rightchild = NULL;
		}
		else			//如果右孩子不为空，则递归插入函数，直到作为叶子结点插入
		{
			this->m_rightchild->insertNode(data);
		}
		return true;
	}
	else								//小的插入到左子树
	{
		if (this->m_leftchild == NULL)			//如果左孩子为空，则直接作为左孩子插入
		{
			this->m_leftchild = new BinNode;
			this->m_leftchild->m_parent = this;
			this->m_leftchild->m_data = data;
			this->m_leftchild->m_id = this->m_id * 2 + 1;
			this->m_leftchild->m_leftchild = NULL;
			this->m_leftchild->m_rightchild = NULL;
		}
		else			//如果左孩子不为空，则递归插入函数，直到作为叶子结点插入
		{
			this->m_leftchild->insertNode(data);
		}
		return true;
	}
}

BinNode* BinNode::getMinNode()
{
	if (this->m_leftchild == NULL)		//没有左孩子，说明自己就是最小的结点
		return this;
	else		//如果左子树存在，则递归左子树，在左子树中找最小的结点
	{
		return this->m_leftchild->getMinNode();
	}
}
BinNode* BinNode::getMaxNode()
{
	if (this->m_rightchild == NULL)		//没有右孩子，说明自己就是最大的结点
		return this;
	else		//如果右子树存在，则递归右子树，在右子树中找最大的结点
	{
		return this->m_rightchild->getMaxNode();
	}
}

BinNode* BinNode::getPreNode()
{
	if (this->m_leftchild == NULL)		//左孩子为空，说明没有前驱
		return NULL;
	return this->m_leftchild->getMaxNode();				//左子树中的最大结点即为前驱
}

BinNode* BinNode::getNextNode()
{
	if (this->m_rightchild == NULL)
		return NULL;		//右孩子为空，说明没有后继
	return this->m_rightchild->getMinNode();		//右子树中的最小结点即为后继
}

BinNode* BinNode::searchNode(int data)
{
	if (this->m_data == data)
		return this;
	else if (data < this->m_data)			//小的在左边
	{
		if (this->m_leftchild == NULL)		//左边已经到底
			return NULL;
		else return this->m_leftchild->searchNode(data);
	}	
	else		//大于等于的在右边
	{
		if (this->m_rightchild == NULL)		//右边已经到底
			return NULL;
		else return this->m_rightchild->searchNode(data);
	}	
}

bool BinNode::inOrderTraverse()
{
	if (this->m_leftchild != NULL)
		this->m_leftchild->inOrderTraverse();
	cout << this->m_data << " ";
	if (this->m_rightchild != NULL)
		this->m_rightchild->inOrderTraverse();
	return true;
}

bool BinNode::deleteNode()
{
	/****************第一种情况，该结点为叶子结点，没有左右孩子，则直接删除结点****************/
	if (this->m_leftchild == NULL && this->m_rightchild == NULL)			
	{
		if (this->m_parent->m_leftchild == this)				//改结点是左叶子
		{
			this->m_parent->m_leftchild = NULL;
			delete this;
			return true;
		}
		else							//该结点是右叶子
		{
			this->m_parent->m_rightchild = NULL;
			delete this;
			return true;
		}
	}

	/*********第二种情况，该结点只有左孩子或者只有右孩子，则用该结点的子树代替该结点********************/
	else if (this->m_leftchild != NULL&& this->m_rightchild == NULL)						//只有左孩子			
	{
		if (this->m_parent->m_leftchild == this)     //该结点是其父结点的左孩子
		{
			this->m_parent->m_leftchild = this->m_leftchild;		//其父结点的左孩子变为其左子节点
			this->m_leftchild->m_parent = this->m_parent;			//千万不要忘记其子结点的父结点也要该变
			delete this;
		}
		else		//该结点是其父结点的右孩子
		{
			this->m_parent->m_rightchild = this->m_leftchild;		//其父结点的右孩子变为其左子节点
			this->m_leftchild->m_parent = this->m_parent;			//千万不要忘记其子结点的父结点也要该变
			delete this;
		}
	}
	else if (this->m_leftchild == NULL && this->m_rightchild != NULL)						//只有右孩子	
	{

		if (this->m_parent->m_leftchild == this)     //该结点是其父结点的左孩子
		{
			this->m_parent->m_leftchild = this->m_rightchild;		//其父结点的左孩子变为其左子节点
			this->m_rightchild->m_parent = this->m_parent;			//千万不要忘记其子结点的父结点也要该变
			delete this;
		}
		else		//该结点是其父结点的右孩子
		{
			this->m_parent->m_rightchild = this->m_rightchild;		//其父结点的右孩子变为其左子节点
			this->m_rightchild->m_parent = this->m_parent;			//千万不要忘记其子结点的父结点也要该变
			delete this;
		}
	}

	/**********最后一种情况，该结点既有左孩子，又有右孩子，则找到该结点的后继代替该结点，该结点后继结点的子树上移（后继结点如果有子树，则一定是右子树）*****************/
	/****后继替换需要删除的结点时，直接用后继结点的数据代替需要删除结点的数据即可。然后将后继结点的子树替换后继结点，最后删除后继结点********/
	else
	{
		BinNode* thisNext= this->getNextNode();					//获取后继结点

		/****************用后继结点代替需要删除的结点this**********************************/
		this->m_data = thisNext->m_data;			//由于删除结点位置的孩子和父亲没有发生改变，所以直接用后继结点的数据替换删除结点的数据即可。否则如果用整个后继结点的内存替换删除结点，还要还原替换后结点的父亲和孩子

		/***************用后继结点的子树代替后继结点的位置******************/
		if (thisNext->m_parent->m_leftchild == thisNext)			//如果后继是其父结点的左子树
		{
			if (thisNext->m_rightchild == NULL)		//后继没有右孩子，也即没有孩子
			{
				thisNext->m_parent->m_leftchild = NULL;
			}
			else
			{
				thisNext->m_parent->m_leftchild = thisNext->m_rightchild;			//父亲孩子结点改变
				thisNext->m_rightchild->m_parent = thisNext->m_parent;				//孩子结点的父亲改变
			}
		}
		else	//后继是其父结点的右子树
		{
			if (thisNext->m_rightchild == NULL)		//后继没有右孩子，也即没有孩子
			{
				thisNext->m_parent->m_rightchild =NULL;
			}
			else
			{
				thisNext->m_parent->m_rightchild = thisNext->m_rightchild;			//父亲孩子结点改变
				thisNext->m_rightchild->m_parent = thisNext->m_parent;				//孩子结点的父亲改变
			}
		}
		delete thisNext;		//由于后继结点的数据已经替换到了删除的结点，此时就可以将后继结点的内存空间删除
	}
}

void BinNode::clean()
{
	if (this->m_leftchild != NULL)
	{
		this->m_leftchild->clean();		//如果左子树存在，则递归删除左子树

	}

	if (this->m_rightchild != NULL)
	{
		this->m_rightchild->clean();	//如果右子树存在，则递归删除右子树
	}

	/***********此时说明this没有左右子树，是叶子结点，使this的父节点指向空，此叶子结点就从树上删除了，但是this本身的空间还未删除，最后还需要再删除this本身的内存********************/
	/***********注意是this的父节点指向空，this才从树上断开。而不是this指向空。仅仅是this指向空，则this的父结点还是指向this，this结点并没有从树上撤下来***********************/
	/***********所以从树上撤下this结点的关键是this的父节点指向空。********************************/
	if (this->m_parent != NULL)			//必须加这句，因为如果是根结点，其m_parent为空时，NULL->m_leftchild访问权限错误，因为NULL是不能访问的
	{
		if (this->m_parent->m_leftchild == this)
		{
			this->m_parent->m_leftchild = NULL;
		}
		if (this->m_parent->m_rightchild == this)
		{
			this->m_parent->m_rightchild = NULL;
		}
	}
	cout << "delete " << this->m_data << endl;
	delete this;			//上面的步骤只是讲this从树上撤下来，但是this本身的内存并没有释放，此时才释放
}
qq_36147149
关注
二叉排序树C/C++代码实现
Ycy的博客
06-29 3141
二叉排序树(二叉查找树): 二叉排序树的一个重要性质：中序遍历一棵二叉 树时可以得到一个结点值递增的有序序列。 对于需要经常进行插入、 删除和查找运算的表，采用二叉排序树比较好 查找： 若二叉排序树为空，则查找失败，返回空指针。 若二叉排序树非空，将给定值key与根结点的关键字T->data.key进行比较： 1,若key等于T->data.key , 则查找成功,返回根结点地址； 2,若key小于T->data.key, 则递归查找左子树； 3,若key大于T->data.key
二叉排序树
02-07
而`二叉排序树`可能包含了实现二叉排序树操作的源代码文件。 总结来说，二叉排序树是一种高效的数据结构，通过不同的遍历方法可以实现多种操作，如查找、插入、删除等。理解其工作原理和遍历方式对于理解和应用数据...
二叉排序树C++代码
12-17
二叉排序树C++代码 字符编码优化 传输 C++代码
二叉查找树（二叉排序树）操作大全C++实现
pleasetojava
11-01 261
// 链式二叉查找树的各种操作.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; using namespace std; struct BSTree { int data; BSTree *left; BSTre...
用C++实现的二叉排序树
05-05
用C++实现的二叉排序树，一种简单的数据结构。
二叉排序树查找c++_二叉查找树的实现
weixin_39794347的博客
12-02 230
入门知识二叉排序树(Binary Sort Tree)，又称二叉查找树(Binary Search Tree)，亦称二叉搜索树。添加递归实现在BinarySearchTree.java 中添加如下代码：/** * * @Title: add * @Description:二叉查找树添加的方法 * @param: data * @return: void * @throws */publi...
二叉排序树的C++实现代码
冒大烟的羊肉串的专栏
09-01 992
//指针传参的函数若是函数中改变指针本身，则照样无法带回到调用处， //若是改变指针指向的值，才能带回 #include #include using namespace std; typedef struct Node {     int value;
二叉排序树模板类c++
02-03
本篇文章将详细介绍如何使用C++语言设计并实现一个二叉排序树模板类。 #### 二、二叉排序树模板类的设计与实现 ##### 2.1 模板类定义 在给定的部分代码中，首先定义了一个模板结构体`BiNode`用于表示二叉排序树中...
二叉排序树C++实现
08-10
二叉排序树的C++实现可能涉及类的定义，包括节点结构、插入、删除、搜索和遍历的方法。文件"Binary sort Tree"可能包含了这些实现细节，具体代码会展示如何创建和操作二叉排序树。通过阅读和理解这些代码，你可以...
二叉排序树资源：可以实现排序功能，c++编写
最新发布
05-29
在C++编程语言中，实现二叉排序树通常涉及以下几个关键步骤和知识点： 1. **结构体定义**：首先，我们需要定义一个结构体来表示二叉树的节点。这个结构体通常包含三个成员：一个整型值（用来存储数据），一个指针...
二叉排序树查找
11-08
第一行输入一个整数t，表示有t组测试数据 第二行起每三行表示一组数据 第1行为输入序列的元素个数：n 第2行为输入的序列：s1 s2 … sn 第3行为输入：sKey iKey dKey 第一行输出中序序列 第二行输出最小值、最大值 第三行输出查找sKey的结果 第四行输出查找后的中序序列 第五行输出插入iKey后的中序序列 第六行输出查找iKey的结果 第七行输出删除dKey后的中序序列 第八行输出查找dKey的结果 Sample Input 1 12 66 45 78 42 55 32 39 68 95 86 102 29 55 63 78 Sample Output 29 32 39 42 45 55 66 68 78 86 95 102 29 102 1 3 2 29 32 39 42 45 55 66 68 78 86 95 102 29 32 39 42 45 55 63 66 68 78 86 95 102 1 4 4 29 32 39 42 45 55 63 66 68 86 95 102 0 5 13
C++二叉排序树代码实现
GT黑喵的博客
07-12 1112
以下是C++控制台程序，实现了二叉排序树的创建和遍历，仅是练习的小程序，分享一下。#include "stdafx.h"#include &lt;iostream&gt;using namespace std;//二叉树节点struct BiTree { int data; BiTree* lchild; BiTree* rchild;};int main(){ BiTree* InsertBST...
[c++]二叉排序树(Binary Sort Tree)详解
EQUINOX1的博客
07-24 1104
二叉树是一种很基础的数据结构，而二叉排序树则是一种插入，删除，查找效率都不错的一种数据结构。二叉排序树的特性就是左子树键值小于根，右子树键值大于根，所以二叉排序树就天然的具有查找功能，有时二叉排序树又叫二叉搜索树或者二叉查找树。
C++——二叉树排序树
博主qq1077644249
02-18 1385
1 二叉搜索树概念 2 二叉搜索树操作与模拟实现 2.1 二叉搜索树的查找 非递归版本 递归版本 2.2 二叉搜索树的插入 非递归版本 递归版本 2.3 二叉搜索树的删除 非递归版本 递归版本 3 二叉搜索树的应用（K模型、KV模型） 4 二叉搜索树的性能分析
二叉搜索树c/c++代码实现
xxxxxiao123的博客
06-30 302
包含了二叉搜索树的插入，删除，查找，中序遍历，找最大值最小值的操作，代码中有注释。 /*Keep on going Never give up*/ //#pragma GCC optimize(3,"Ofast","inline") #include <bits/stdc++.h> using namespace std; struct Node{ int data; Node *l,*r,*parent; }; //由大到小排序（中序遍历二叉树） void sortx(Nod
查找算法--二叉排序树算法（C++实现完整代码）
weixin_45482422的博客
08-31 1471
如下图所示是某个排序二叉树，什么是排序二叉树？。。。 下面的算法实现的是查找某个关键字是否在这棵树上的某个节点中。算法分为俩个部分，第一部分为二叉排序树的创建，第二部分是二叉排序树查找算法； #include <iostream> using namespace std; typedef struct BTNode { int key; struct BTNode *lchild; struct BTNode *rchild; }BTNode; void createBST(BTNode
c++实现二叉排序树
weixin_42578963的博客
12-28 294
二叉排序树是一种特殊的二叉树，它的特点是满足二叉排序树的任意一个节点的值都大于它的左子树中的任意节点的值，而小于它的右子树中的任意节点的值。 下面是 c 语言实现二叉排序树的算法： 定义二叉排序树的结构体，包含节点值、左右子节点指针。 struct BinarySortTree { int val; struct BinarySortTree *left; struct Binar...
用c++实现一个二叉排序树
f905699146的博客
06-19 1973
二叉排序树又称二叉查找树（Binary Search Tree）。其定义为：二叉排序树或者收空树，或者是满足如下性质的二叉树。 （1）若它的左子树非空，则左子树上所有节点的值均小于根节点的值。 （2）若它的右子树非空，则右子树上所有节点的值均大于根节点的值。 （3）左右子树本身又各是一颗二叉排序树。 二叉排序树数据结构如下：//节点类定义 class Node { int dat
实现二叉排序树的添加C++语言代码
06-08
以下是C++语言实现二叉排序树添加节点的代码： ```cpp #include using namespace std; // 二叉排序树节点定义 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值
>