二叉排序树BST的插入，查询和删除，c/c++描述

最新推荐文章于 2023-05-25 12:06:43 发布
最新推荐文章于 2023-05-25 12:06:43 发布
阅读量809 收藏 2
点赞数 1
分类专栏： 数据结构c/c++描述 文章标签： 数据结构 算法 c++ c语言 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangzhangkeji/article/details/119681803
版权

  关于查找，对于表的线性存储，可以采用顺序查找，二分查找，插值查找，斐波那契查找和分块查找。为了同时提高表的查询和插入删除性能，可以采用链式存储，采用二叉树结构。
  二叉排序树，binary sort tree 。 建立对应于表的二叉排序树，要求树里 ： 左子节点的关键字 < 根节点的关键字 < 右子节点的关键字。这样，如果按树的中序输出，可以得到表里记录的关于关键字值的递增排列。所以二叉排序树实现了对表里记录的有序存储。
  表用一位数组存储，关键字就是数组里元素的值，要求不能有值相同的元素，或者称为记录。
  对二叉排序树的插入删除和查询效率都很高，对于平衡二叉树来讲，接近于折半查找的效率。
  BST的建立过程，就是树里节点的插入过程。其是递归的。从BST里查找记录，也是递归的。从BST里删除节点，要区分该节点的位置。
  若删除的节点是叶节点，直接删除即可。
  若删除的节点只有左子树或者右子树，则需要在排序树里保留左子树或者右子树。
  若删除的节点既有左子树又有右子树，则需要对其左子树和右子树合并，合并后的子树的根节点为原左子树的最右下角节点或者，原右子树的最左下角节点。因为我们要保证删除节点后的树仍然是二叉排序树，其中序排列（左根右），是表里记录的递增排列。
  左子树的最右下节点是左子树的中序值最大节点。右子树的最左下节点，是右子树的中序值最小节点。这两个节点，都适合作为左右子树合并后的新的根节点。
  若最右下节点含有左子节点或者最左下节点含有右子节点，则还要在树里保留这些子节点。
  删除节点的情况，除了要先找到该被删除节点，还要找到其父母节点的位置，以保证整个表里节点的连续性。
  删除节点时还要区分被删节点是否是根节点。两种情况下的程序组织是不一样的，因为根节点在被删除前，root需要指向BST新的根。而且root是没有父母节点的。
  各函数功能如下：
  函数insertBST：插入法建立BST。因为例题中首个插入节点是4 ，所以根节点的值始终为4.
  函数searchBSTRecursion ： 用递归方法查找BST里是否含有数值data，有，则输出根节点到被查节点的路径。类似于递归方法老鼠走迷宫的方案，用一个数组作为该函数参数，记录走过的路径、遍历过的节点。
  函数searchBSTNoRecursion：用非递归的方法查找BST里，是否有数值data，同样用一个数组存储遍历过的节点数据。查找时，都要考虑BST里没有被查数据的情况。因为BST已经中序有序，不必用广度优先的遍历了。虽然调用二叉树的广度优先遍历方法也可以。
  函数inOrderTraverse：输出BST的中序遍历结果，其应该是递增的，以检查BST的建立和删除过程是否正确。
  函数displayBST：输出BST的逗号表达式形式，以检验二叉树的建立是否正确，这是一个复习题。其实用中序遍历输出也可以。故只调用了该函数一次，因为其结果不直观。
  函数deleteBST(Node*& root, int data)：从BST里删除指定的数据节点。该函数最为复杂，费脑筋。要综合考虑树是否为空树，是否包含待删节点，待删节点是否为根节点，待删节点是否还有左右子树。具体过程结合上面分析。该函数我自己写的，略嫌繁琐，但结果是正确的，没有用递归。
  以下是全部代码，先是main函数所在源文件：

#include<iostream>
using namespace std;

struct Node {
	int data;
	Node* ptLeftChild;
	Node* ptRightChild;
};

extern void insertBST(Node * & root,int data);
extern void searchBSTRecursion(Node*& root, int data,int path[],int length);
extern void searchBSTNoRecursion(Node*& root, int data,int path[],int length);
extern void deleteBST(Node*& root, int data);
extern void inOrderTraverse(Node*& root);
extern void displayBST(Node*& root);

int main() {
	int a[] = {4,9,0,1,8,6,3,5,2,7},length = 10;
	Node* root = NULL;

	for (int i = 0; i < length; i++)
		insertBST(root,a[i]);

	cout << "middle order traverse : ";
	inOrderTraverse(root);

	cout<<endl<<"逗号表达式表示该二叉树 ：";
	displayBST(root);

	int path[20];
	cout << endl<<endl;
	searchBSTNoRecursion(root,6,path,0);
	searchBSTNoRecursion(root,11,path, 0);
	
	cout << endl;
	searchBSTRecursion(root,11,path,0);
	searchBSTRecursion(root, 6, path, 0);

	cout << endl << "delete 4 : ";
	deleteBST(root,4);
	inOrderTraverse(root);
	cout << endl;

	cout << endl << "dalete 5 : ";
	deleteBST(root,5);
	inOrderTraverse(root);
	cout << endl;

	cout << endl << "dalete 99 : ";
	deleteBST(root,99);

	return 0;
}

接着是各函数所在源文件：

#include<iostream>
using namespace std;

struct Node {
	int data;
	Node* ptLeftChild;
	Node* ptRightChild;
};

void insertBST(Node*& root, int data) {
	if (root == NULL) {
		root = new Node;
		root->data = data;
		root->ptLeftChild = root->ptRightChild = NULL;
		return;
	}

	if (root->data > data)
		insertBST(root->ptLeftChild, data);
	else if (root->data < data)
		insertBST(root->ptRightChild,data);
	else 
		cout << "key " <<data<<" repeated ! " << endl;
}

void searchBSTRecursion(Node*& root, int data,int path[],int length) {
	if (root == NULL) {
		cout << "recursion,list do not include this data : "<<data << endl;
		return;
	}

	if (root->data > data) {
		path[length] = root->data;
		length++;
		searchBSTRecursion(root->ptLeftChild, data, path, length);
	}
	else if (root->data < data) {
		path[length] = root->data;
		length++;
		searchBSTRecursion(root->ptRightChild,data,path,length);
	}
	else {
		cout << "recursion,path from root to " << data << " : ";
		for (int i = 0; i < length; i++)
			cout << path[i] << " ";
		cout << data << endl;
	}
}

void searchBSTNoRecursion(Node*& root, int data,int path[],int length) {
	Node* pt = root;
	while (pt != NULL) 
		if (pt->data > data) {
			path[length] = pt->data;
			length++;
			pt = pt->ptLeftChild;
		}
		else if (pt->data < data) {
			path[length] = pt->data;
			length++;
			pt = pt->ptRightChild;
		}
		else {
			cout << "no recursion ,from root to " << data << " : ";
			for (int i = 0; i < length; i++)
				cout << path[i] << ' ';
			cout << data << endl;
			return;
		}
	
	cout << "no recursion ,list has no this data : " << data << endl;
}

void deleteBST(Node*& root, int data) {
	if (root == NULL) {
		cout << "list is empty ! " << endl;
		return;
	}

	Node* ptDelete, * ptLeftMAX, * ptParentLeftMax, * ptParentDele = NULL;
	if (root->data == data) {
		ptDelete = root;
		if (root->ptLeftChild == NULL && root->ptRightChild == NULL) 
			root = NULL;
		else if (root->ptLeftChild != NULL && root->ptRightChild == NULL) 
			root = root->ptLeftChild;
		else if (root->ptLeftChild == NULL && ptDelete->ptRightChild != NULL) 
			root = root->ptRightChild;
		else if (root->ptLeftChild->ptRightChild == NULL) {
			root = root->ptLeftChild;
			root->ptRightChild = ptDelete->ptRightChild;
		}
		else {
			ptParentLeftMax = root->ptLeftChild;
			ptLeftMAX = ptParentLeftMax->ptRightChild;
			while (ptLeftMAX->ptRightChild != NULL) {
				ptParentLeftMax = ptLeftMAX;
				ptLeftMAX = ptParentLeftMax->ptRightChild;
			}
				
			root = ptLeftMAX;

			if (ptLeftMAX->ptLeftChild != NULL)
				ptParentLeftMax->ptRightChild = ptLeftMAX->ptLeftChild;
			else
				ptParentLeftMax->ptRightChild = NULL;
			
			root->ptLeftChild = ptDelete->ptLeftChild;
			root->ptRightChild = ptDelete->ptRightChild;
		}
		
		delete ptDelete;
		return;
	}

	ptDelete = root;
	int leftRight;  // 1 is left ,2 is right
	while (ptDelete != NULL && ptDelete->data != data) {
		ptParentDele = ptDelete;

		if (ptDelete->data > data) {
			ptDelete = ptParentDele->ptLeftChild;
			leftRight = 1;
		}
		else {
			ptDelete = ptParentDele->ptRightChild;
			leftRight = 2;
		}
	}

	if (ptDelete == NULL) {
		cout << "list is not empty, but has no this data : " << data << endl;
		return;
	}

	if(ptDelete->ptLeftChild == NULL && ptDelete->ptRightChild == NULL)
		if (leftRight == 1) 
			ptParentDele->ptLeftChild = NULL;
		else 
			ptParentDele->ptRightChild = NULL;
	else if(ptDelete->ptLeftChild != NULL && ptDelete->ptRightChild == NULL)
		if (leftRight == 1) 
			ptParentDele->ptLeftChild = ptDelete->ptLeftChild;
		else 
			ptParentDele->ptRightChild = ptDelete->ptLeftChild;
	else if(ptDelete->ptLeftChild == NULL && ptDelete->ptRightChild != NULL)
		if (leftRight == 1) 
			ptParentDele->ptLeftChild = ptDelete->ptRightChild;
		else 
			ptParentDele->ptRightChild = ptDelete->ptRightChild;
	else if (ptDelete->ptLeftChild->ptRightChild == NULL) 
		if (leftRight == 1) {
			ptParentDele->ptLeftChild = ptDelete->ptLeftChild;
			ptDelete->ptLeftChild->ptRightChild = ptDelete->ptRightChild;
		}
		else{
			ptParentDele->ptRightChild = ptDelete->ptLeftChild;
			ptDelete->ptLeftChild->ptRightChild = ptDelete->ptRightChild;
		}
	else {
		ptParentLeftMax = ptDelete->ptLeftChild;
		ptLeftMAX = ptParentLeftMax->ptRightChild;
		
		while (ptLeftMAX->ptRightChild != NULL) {
			ptParentLeftMax = ptLeftMAX;
			ptLeftMAX = ptParentLeftMax->ptRightChild;
		}
	
		if (leftRight == 1)
			ptParentDele->ptLeftChild = ptLeftMAX;
		else
			ptParentDele->ptRightChild = ptLeftMAX;

		if (ptLeftMAX->ptLeftChild != NULL)
			ptParentLeftMax->ptRightChild = ptLeftMAX->ptLeftChild;
		else
			ptParentLeftMax->ptRightChild = NULL;
	
		ptLeftMAX->ptLeftChild = ptDelete->ptLeftChild;
		ptLeftMAX->ptRightChild = ptDelete->ptRightChild;
	}

	delete ptDelete;
}

void inOrderTraverse(Node*& root) {
	if (root == NULL)
		return;

	inOrderTraverse(root->ptLeftChild);
	cout << root->data << ' ';
	inOrderTraverse(root->ptRightChild);
}

void displayBST(Node*& root) {
	if (root == NULL)
		return;

	cout << root->data;
	if (root->ptLeftChild != NULL || root->ptRightChild != NULL) {
		cout << '(';
		displayBST(root->ptLeftChild);
		
		if (root->ptRightChild != NULL) {
			cout << ',';
			displayBST(root->ptRightChild);
		}

		cout << ')';
	}
}

测试结果和对应的BST树如下：
在这里插入图片描述
在这里插入图片描述
谢谢阅读。为了编写健壮的delete函数，多花费了3小时。

zhangzhangkeji
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】查找算法
qq_45813532的博客
09-03 5306
查找：在数据集合中寻找满足某种条件的数据元素的过程称为查找。 查找表：用于查找的数据集合称为查找表，它由同一类型的数据元素组成，可以是一个数组或链表等数据类型。从名义上来看，查找表是一种新的数据结构，但实际上它指的就是用线性表，树或者图结构来存储数据，只不过数据间的逻辑关系是人为赋予的。数据结构中，将存储无逻辑关系数据的线性表，树或者图结构统称为查找表。查找表常见操作：如果只对查找表做前俩种操作，不改变查找表的存储结构，这样的查找表称为静态查找表；反之，如果对查找表做插入或者删除操作，查找表的结构发生了变化
二叉排序树（BST）的构建与删除
卖核弹的小男孩 的博客
04-29 271
二叉排序树（BST）的构建，插入，查找与删除 二叉排序树的删除结点分为三种情况 （1）叶子结点 这种情况最简单，由于删除叶子结点不会破坏整棵树的结构，只需要修改其双亲结点的指针即可 （2）要删除的结点只求左子树或者右子树 相对而言也比较简单，只需要删除结点后，将它的左子树或右子树整个移动到删除节点的位置即可。 #include<iostream> using namespace std...
C++ 不知树系列之二叉排序树（递归和非递归遍历、删除、插入……）
y6123236的专栏
11-04 1430
本文讲解了什么是二叉排序树，并深入地探讨在二叉排序树如何进行数据的插入、遍历、删除……
C++ 二叉排序树的删除 学习笔记
van9527的博客
07-14 387
C++ 二叉排序树的删除 学习笔记
二叉排序树的查找、插入、删除
Dream_begin_的博客
05-25 1276
二叉排序树的定义二叉排序树（Binary Sort Tree， BST），也称二叉查找树。二叉排序树或者是一棵空树，或者是一棵具有下列特性的非空二叉树：1） 若左子树非空，则左子树上所有结点关键字均小于根结点的关键字值；2） 若右子树非空，则右子树上所有结点关键字均大于根结点的关键字值；3） 左、右子树本身也分别是一棵二叉排序树。由定义可知，二叉排序树是一个递归的数据结构，可以方便的使用递归算法对二叉排序树进行各种运算。
《算法》使用C/C++语言实现二叉排序树
01-02
由于这些特点，二叉排序树通常用于实现动态集合的数据结构，可以高效地支持插入、删除和查找操作。在二叉排序树中，插入和查找操作的平均时间复杂度为O(log n)，其中n是树中结点的数量。然而，如果树的结构不平衡，...
二叉排序树 建立 查询 删除
05-08
二叉排序树（Binary Search Tree，BST），也称为二叉查找树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键值、一个指向左子树的指针和一个指向右子树的指针。在二叉排序树中，对于任意节点，其左子树中的...
C++二叉排序树.zip
05-29
二叉排序树（Binary Search Tree，BST），也称为二叉查找树或有序二叉树，是一种自平衡的二叉树数据...在实际编程中，理解并能灵活运用二叉排序树的插入、查找和删除操作，是成为一名优秀的C++程序员的基础技能之一。
基于C++的二叉排序树（免费提供源码）
最新发布
06-14
二叉排序树（BST，Binary Search Tree）是一种重要的数据结构，广泛应用于数据检索、排序和动态集合操作。基于C++的二叉排序树实现，提供了一种高效的方式来管理和操作数据。以下是这种实现的简要介绍。 二叉排序树...
二叉排序树C++
01-21
在实际编程中，这些概念和方法可以结合C++的面向对象特性进行封装，创建一个二叉排序树类，提供插入、查找、删除等方法，并实现相应的逻辑。通过练习和实践，可以深入理解二叉排序树的工作原理及其在数据结构和算法...
C++二叉排序树的创建、插入、删除、查找
09-30
二叉排序树，用前序遍历是就是增序排列，的创建删、插入、查询
二叉排序树创建-查找-删除
11-09
二叉排序树创建-查找-删除，算法数据结构基础篇章，可供创建二叉排序树后对其进行插入-查找-删除等操作。
二叉树（排序树）的创建、遍历、插入、删除以及查找
weixin_43126491的博客
08-11 3587
二叉树（排序树）的创建、遍历、插入、删除以及查找 原理：二叉树的先序创建（递归）按先序遍历的顺序，依次 输入结点的信息建成立二叉链表的算法。该算法的基本思想是：首先对一般的二叉树添加若干个虚结点，使每一个节点都有左右两个孩子，然后依次输入结点信息。若输入的结不是虚结点，则建立一个新结点；先序创建左子树；先序创建右子树 在这里插入代码片 ...
C++搜索二叉树的查找、插入、删除
MilkLeong的博客
02-15 2353
以一年十二月的英文缩写为键值而产生二叉搜索树，查找其中的Feb值，及输出最小、最大值： 红框以内为输出，红框以外为输入。
二叉排序树的构造、查找、插入及删除算法的实现(C++)
shidalong2014的专栏
01-06 3069
二叉排序树的构造、查找、插入及删除算法的实现(C++) 转自这里 #include using namespace std; class BsTree { public: // 构造函数初始化树根为NULL，表示空树 BsTree (void) : m_pRoot (NULL), m_uSize (0) {} // 析构函数清空树 ~BsTree (void) { Clear
二叉排序树(BST)的思路及C语言实现
kelvinmao的博客
05-31 1万+
请注意，为了能够更好的理解二叉排序树，我建议各位在看代码时能够设置好断点一步一步跟踪函数的运行过程以及各个变量的变化情况一.动态查找所面临的问题在进行动态查找操作时，如果我们是在一个无序的线性表中进行查找，在插入时可以将其插入表尾，表长加1即可；删除时，可以将待删除元素与表尾元素做个交换，表长减1即可。反正是无序的，当然是怎么高效怎么操作。但如果是有序的呢？回想学习线性表顺序存储时介绍的顺序表的缺点
using c++ in BST search,insert,delete
hellobettershero的博客
03-21 225
//using c++ in BST #include<iostream> using namespace std; class BST{ int data; BST *left,*right; public: BST(); // Default constructor. BST(int); // Parameterized...
BST 存储结构建立（插入）、删除、 查找算法的实现及应用
热门推荐
idevede的博客
02-13 1万+
这是最后一次数据结构实验，排序部分
C++实现二叉排序树：插入、删除与查找
这篇文档主要涵盖了二叉排序树（Binary Search Tree，BST）的基本操作，包括建立、插入、删除和查找，这些都是数据结构课程设计的重要部分。二叉排序树是一种特殊类型的数据结构，它的每个节点都满足以下条件：左...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值