C++——算法基础之动态查找表1——二叉排序树

最新推荐文章于 2022-09-15 20:20:00 发布
最新推荐文章于 2022-09-15 20:20:00 发布
阅读量961 收藏 5
点赞数 1
分类专栏： 算法基础 文章标签： C++ 二分查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QLY1798LOVE/article/details/52450785
版权

二叉排序树的简单操作：

（1）查找，——类似于二分查找（较简单，略）

（2）插入，——若新结点已存在，则不插入；否则，插入（较简单，略）

（3）删除，——由于结点的删除会对树造成影响；所以，我们重点谈谈。

分类：

1）删除的结点为叶子结点  ——   直接删除，然后使其  = NULL

2）删除的结点为单孩子结点  ——   让其双亲结点指向它的孩子结点，然后使其  = NULL

2）删除的结点为双孩子结点  ——   

方法一：让其左孩子代替它，其右孩子接在其左孩子的最右端

1，,可通过修改结点的值来实现——>前提：递归比较6

2，可通过修改指针来实现——>比较符合初学者

方法二：让其右孩子的最左端代替它，这个最左端的右孩子代替这个最左端。

坑点：1，当删除叶子结点时，应在主树中将其置为空，否则在遍历时会出现异常。

    2，当获取某个结点的值时，在不确定的情况下，需判断其是否为空。

下面结合图和代码仔细研读（图有点烂哈）




#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <functional>
#include <algorithm>
#include <numeric>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <cstring>
#include <conio.h>
using namespace std;

#define NULL 0

struct bstnode
{
	int key;
	bstnode *lchild, *rchild;
};

bstnode *root = NULL;			//根结点
bstnode *parent = NULL;			//待插入位置的双亲结点

int bstsearch (int key)
{
	struct bstnode *ps;
	int mark;			//查找标志：0->空树；1->查找成功；2->查找失败，应插入到左子树中；3->查找失败，应插入到右子树中
	if(!root)
	{
		mark = 0;
	}
	else
	{
		ps = root;
		while(ps)
		{
			if(ps->key == key)
			{
				mark = 1;
				break;
			}
			else if(ps->key > key)
			{
				parent = ps;
				ps = ps->lchild;
				mark = 2;
			}
			else
			{
				parent = ps;
				ps = ps->rchild;
				mark = 3;
			}
		}
	}
	return mark;
}

int bstinsert (int key)
{
	bstnode *point;
	int mark, flag;				//falg：0-》插入 1-》未插入
	mark = bstsearch (key);
	if(1 == mark)
	{
		flag = 1;
	}
	else
	{
		point = (bstnode *)malloc (sizeof (bstnode));
		if(!point)
		{
			cout << "Memory overflow!";
			_getch ();
			exit (0);
		}
		point->key = key;
		point->lchild = NULL;
		point->rchild = NULL;
		if(mark == 0)
		{
			root = point;
			flag = 0;
		}
		else if(mark == 2)
		{
			parent->lchild = point;
			flag = 0;
		}
		else
		{
			parent->rchild = point;
			flag = 0;
		}
	}
	return flag;
}

void bst_inorder (bstnode *point)
{
	if(point)
	{
		bst_inorder (point->lchild);
		cout << "  " << point->key;
		bst_inorder (point->rchild);
	}
}

//修改值
int bstdelete (bstnode ** del_root, int key)
{
	bstnode *ps, *left;
	if(*del_root == NULL)			//二叉树为空
	{
		return 0;
	}
	else
	{
		if(key < (*del_root)->key)		//待删除结点在左子树
		{
			cout << "left\t";
			_getch ();
			return bstdelete (&(*del_root)->lchild, key);
		}
		if(key > (*del_root)->key)		//待删除结点在右子树
		{
			cout << "right\t";
			_getch ();
			return bstdelete (&(*del_root)->rchild, key);
		}
		ps = *del_root;										//找到待删除结点
		if(ps->lchild == NULL && NULL == ps->rchild)		//待删除结点为叶子结点
		{
			*del_root = NULL;
			free (ps);
			return 1;
		}
		if(ps->lchild == NULL)								//待删除结点只有右子树
		{
			*del_root = (*del_root)->rchild;
			free (ps);
			return 1;
		}
		if(ps->rchild == NULL)								//待删除结点只有左子树
		{
			*del_root = (*del_root)->lchild;
			free (ps);
			return 1;
		}
		else
		{
			if((*del_root)->lchild->rchild == NULL)
			{
				(*del_root)->key = (*del_root)->lchild->key;
				return bstdelete (&ps->lchild, (*del_root)->key);
			}
			left = ps->lchild;
			while(left->rchild != NULL)
			{
				ps = left;
				left = left->rchild;
			}
			(*del_root)->key = left->key;
			return bstdelete (&ps->rchild, (*del_root)->key);
		}
	}
}

//修改指针1					//还需修改
int bstdelete2 (int key)
{
	if(!root)
	{
		return 0;
	}
	int flag = bstsearch (key);				//判断root中是否存在key
	if(1 != flag)
	{
		return 0;
	}
	bstnode *ps = root;
	if(ps->key == key)									//当删除结点为根结点时
	{
		if(ps->lchild == NULL && ps->rchild == NULL)
		{
			free (ps);
			root = NULL;
			ps = NULL;
			return 1;
		}
		if(ps->lchild == NULL)
		{
			root = ps->rchild;
			free (ps);
			ps = NULL;
			return 1;
		}
		if(ps->rchild == NULL)
		{
			root = ps->lchild;
			free (ps);
			ps = NULL;
			return 1;
		}
		else
		{
			root = ps->lchild;
			bstnode *pCur = ps->lchild;
			while(pCur->rchild)
			{
				pCur = pCur->rchild;
			}
			pCur->rchild = ps->rchild;
			free (ps);
			ps = NULL;
			return 1;
		}		
	}
	else									//当删除结点不为根结点时
	{
		while(key != ps->key)				//找到待删除结点
		{
			parent = ps;					//parent为待删除结点的双亲结点
			if(key < ps->key)
			{
				ps = ps->lchild;
			}
			else
			{
				ps = ps->rchild;
			}
		}
		if(ps->lchild == NULL && ps->rchild == NULL)				//待删除结点为叶子结点
		{
			if(parent->lchild != NULL && parent->lchild->key == key)
			{
				parent->lchild = NULL;
			}
			else
			{
				parent->rchild = NULL;
			}
			free (ps);
			ps = NULL;
			return 1;
		}
		if(ps->lchild == NULL)					//待删除结点只含有右子树
		{
			if(parent->lchild != NULL && parent->lchild->key == ps->key)		//判断待删除结点为双亲结点的哪个孩子
			{
				parent->lchild = ps->rchild;
			}
			else
			{
				parent->rchild = ps->rchild;
			}
			free (ps);
			ps = NULL;
			return 1;
		}
		if(ps->rchild == NULL)								//待删除结点只含有左子树
		{
			if(parent->lchild != NULL && parent->lchild->key == ps->key)
			{
				parent->lchild = ps->lchild;
			}
			else
			{
				parent->rchild = ps->lchild;
			}
			free (ps);
			ps = NULL;
			return 1;
		}
		else							//待删除结点既有右子树又有左子树
		{
			if(parent->lchild != NULL && parent->lchild->key == ps->key)
			{
				parent->lchild = ps->lchild;
			}
			else
			{
				parent->rchild = ps->lchild;
			}
			bstnode *pCur = ps->lchild;
			while(pCur->rchild)
			{
				pCur = pCur->rchild;
			}
			pCur->rchild = ps->rchild;
			free (ps);
			ps = NULL;
			return 1;	
		}		
	}
}

//修改指针2
int bstdelete3 (int key)
{
	if(!root)
	{
		return 0;
	}
	int flag = bstsearch (key);
	if(1 != flag)
	{
		return 0;
	}
	bstnode *ps = root;
	if(key == ps->key)					//待删除结点为根结点
	{
		if(ps->lchild == NULL && ps->rchild == NULL)
		{
			free (ps);
			root = NULL;
			ps = NULL;
			return 1;
		}
		else if(ps->lchild == NULL)
		{
			root = ps->rchild;
			free (ps);
			ps = NULL;
			return 1;
		}
		else if(ps->rchild == NULL)
		{
			root = ps->lchild;
			free (ps);
			ps = NULL;
			return 1;
		}
		else
		{
			bstnode *pCur = ps->rchild;
			if(pCur->lchild == NULL)				//待删除结点的右子树没有左子树
			{
				pCur->lchild = ps->lchild;
				root = pCur;
				free (ps);
				return 1;
			}
			else
			{
				while(pCur->lchild)
				{
					parent = pCur;					//parnet为欲取代待删除结点的双亲结点
					pCur = pCur->lchild;
				}
				root = pCur;
				if(parent->lchild != NULL && parent->lchild->key == pCur->key)
				{
					parent->lchild = pCur->rchild;
				}
				else
				{
					parent->rchild = pCur->rchild;
				}
				pCur->lchild = ps->lchild;
				pCur->rchild = ps->rchild;
				free (ps);
				ps = NULL;
				return 1;
			}			
		}
	}
	else								//待删除结点为非根结点
	{
		while(key != ps->key)
		{
			parent = ps;				//parent为待删除结点的双亲结点
			if(key < ps->key)
			{
				ps = ps->lchild;
			}
			else
			{
				ps = ps->rchild;
			}
		}
		if(ps->lchild == NULL && ps->rchild == NULL)
		{
			if(parent->lchild != NULL && parent->lchild->key == key)
			{
				parent->lchild = NULL;
			}
			else
			{
				parent->rchild = NULL;
			}
			free (ps);
			ps = NULL;
			return 1;
		}
		else if(ps->lchild == NULL)
		{
			if(parent->lchild != NULL && parent->lchild->key == key)
			{
				parent->lchild = ps->rchild;
			}
			else
			{
				parent->rchild = ps->rchild;
			}
			free (ps);
			ps = NULL;
			return 1;
		}
		else if(ps->rchild == NULL)
		{
			if(parent->lchild != NULL && parent->lchild->key == key)
			{
				parent->lchild = ps->lchild;
			}
			else
			{
				parent->rchild = ps->lchild;
			}
			free (ps);
			ps = NULL;
			return 1;
		}
		else
		{
			bstnode *pCur = ps->rchild;					//pCur为欲取代结点
			bstnode *pPre = NULL;						//pPre为欲取代结点的双亲结点
			if(pCur->lchild == NULL)
			{
				if(parent->lchild != NULL && parent->lchild->key == key)
				{
					parent->lchild = pCur;
				}
				else
				{
					parent->rchild = pCur;
				}
				pCur->lchild = ps->lchild;
				free (ps);
				return 1;
			}
			else
			{
				while(pCur->lchild)
				{
					pPre = pCur;
					pCur = pCur->lchild;
				}
				if(parent->lchild != NULL && parent->lchild->key == key)
				{
					parent->lchild = pCur;
				}
				else
				{
					parent->rchild = pCur;
				}
				if(pPre->lchild != NULL && pPre->lchild->key == pCur->key)
				{
					pPre->lchild = pCur->rchild;
				}
				else
				{
					pPre->rchild = pCur->rchild;
				}
				pCur->lchild = ps->lchild;
				pCur->rchild = ps->rchild;
				free (ps);
				ps = NULL;
				return 1;
			}			
		}
	}
}

int main()
{
	int kx, falg;
	cout << "\n This is bin_sort_tree_insert...";
	while(true)
	{
		cout << "\n\n pelease input the key want to insert('0' to exit):";
		cin >> kx;
		if(kx == 0)
		{
			break;
		}
		falg = bstinsert (kx);
		if(1 == falg)
		{
			cout << "\n\tFound ! And " << kx << "has been int the tree.";
		}
		else
		{
			cout << "\n\t Not found ! And " << kx << "has been inserted into the tree.";
		}
	}
	cout << "\n The bin_sort_tree is : \n";
	bst_inorder (root);
	while(true)
	{
		cout << "\n\n please input the key want to delete:";
		cin >> kx;
		falg = bstdelete3 (kx);
		if(1 == falg)
		{
			cout << "\n\n\t" << kx << " has been deleted.......";
		}
		else
		{
			cout << "\n\t Failure!";
		}
		cout << "\n\n The bin_sort_tree is :\n";
		bst_inorder (root);
		cout << endl;
	}	
	return 0;
}


暮雨灬倾晨
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
查找表问题（c++）
秋人别院
09-02 1215
分类 查找有无 查找’a’是否存在？使用集合：set，unordered_set 查找对应关系（键值对应） 元素’a’出现了几次？使用字典：map，unordered_map set & map基本用法 insert find erase change (map) 举例说明（LeetCode）349. Intersection of Two Arrays求两个集合的交集元素，相同元素只记录一次。
数据结构平衡二叉排序树
02-13
在本实验中，我们主要探讨的是数据结构中的一个关键概念——平衡二叉排序树（Balanced Binary Sort Tree），也称为AVL树。AVL树是一种自平衡的二叉搜索树，它的每个节点都包含一个平衡因子，这个因子是该节点的左...
动态查找表 || 二叉排序树的c++实现
perry0528的博客
03-21 410
二叉排序树的特性： 若左子树不空，左子树上所有结点的值均小于它的根结点值。 若右子树不空，右子树上所有结点的值均大于它的根结点值。 左右子树分别为二叉排序树。 删除算法： 被删除的结点是叶子结点。 被删除的结点只有左子树或有右子树。 被删除的结点既有左子树又有右子树。 对于第三种我们选择删除结点的左子树的最右结点。 查找性能的分析： （平均查找长度） 不同树的平均查找长度不同，即使是相同序...
【源代码】C++数据结构算法（十三）动态查找——二叉排序树
Handoking的博客【学无止境】
05-10 498
日常说明：有错误欢迎大家指正。另外本博客所有的代码博主编写后均调试通过。重要提醒！！！！博主使用的是VS2017，如果有低版本的小伙伴最好新建空项目将此代码复制上去。 更多算法请关注我的算法专栏https://blog.csdn.net/column/details/20417.html 运行截图： 本算法采用比较简单，也比较局限的方法。先用先序遍历建树，然后再进行查找。相对于可输...
动态查找问题(C++)
沛竹君的博客
03-05 215
题目描述 Time Limit: 1000 ms Memory Limit: 256 mb 有n个整数的集合，想让你从中找出x是否存在。 输入输出格式 输入描述: 第一行输入一个正整数n（n < 100000） 第二行输入n个正整数，用空格隔开。 第三行输入一个正整数q（q<100000），表示查询次数。 接下来输入q行，每行一个正整数x，查询x是否存在。 输出描述...
C++ 动态查找问题
BLOG OF PETERMAOSX.
01-14 356
查找类问题： 1、数字查找：给你一堆数字，让你在其中查找x是否存在 2、字符串查找：给你很多字符串，让你在其中找出字符串s是否存在 面对大量的数据量，很多人的想法是先sort排序，然后二分查找。可以使用map来做。 问题：有n个整数的集合，想让你从中找出x是否存在。 输入描述： 第一行输入一个正整数n 第二行输入n个正整数 第三行输入一个q，表示查询次数 接下来输入q行，每行一个正整数x，查询x是...
数据结构与算法基础课程 C语言C++程序语言设计教程8_1集合与查找（静态查找、哈希、二叉排序树、平衡二叉树）共28页.pptx
最新发布
07-20
本章节主要介绍了集合的概念及其运算、静态查找表和散列表的相关知识，并重点探讨了二叉排序树这一重要的动态查找表结构。通过对这些内容的学习，可以更好地理解如何高效地进行数据查找和管理，为后续深入学习更复杂...
查找算法代码C++——包括顺序、二分、BST、哈希
06-26
本资源提供了C++实现的四种主要查找算法：顺序查找、二分查找、BST（二叉搜索树）查找以及哈希查找。下面将详细阐述这四种查找算法及其在C++中的实现。 1. **顺序查找**： 顺序查找是最基础的查找方法，适用于任何...
数据结构课程设计——二叉排序树
02-18
### 数据结构课程设计——二叉排序树 #### 一、二叉排序树概念 二叉排序树(Binary Search Tree)，也称作二叉查找树或有序二叉树，是一种特殊的二叉树数据结构。它具有以下性质： 1. 若任意节点的左子树不空，则左...
数据结构 综合性实验 实现二叉排序树的各种算法功能 有源码 有实验报告
09-05
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉排序树（Binary Sort Tree，BST），这是一种特殊的二叉树，具有高效的查找、插入和删除操作。二叉排序树的特性是左子树上的所有节点的值都小于根节点，...
数据结构课程设计--动态查找表 二叉排序树
06-29
数据结构课程设计--动态查找表 用二叉排序树实现动态查找表的虚拟数据类型
数据结构动态查找表
01-03
数据结构ADT动态查找表 动态查找表的特点和抽象数据类型ADT DynamicSearchTable 存储结构定义、 算法设计
实现动态查找表的三种基本功能
05-31
实现动态查找表的基本操作，其中包括查找，插入以及删除
动态查找之二叉排序树，C++代码实现
成长的足迹
12-23 3138
<br />#include <iostream> using namespace std; typedef struct BSTNode { int key; struct BSTNode *lchild,*rchild; }BSTNode,*BSTree; //二叉排序树的插入——递归实现 void InsertBST(BSTree &DT,BSTNode *p) { if(DT==NULL) DT=p; else if((DT->key) > (p->key))
C++查找算法（更新中）
weixin_43828675的博客
03-17 214
C++的查找分为静态查找与动态查找。 静态查找：只是在查找表中判断是否有这一个元素，取出这个元素的属性。 动态查找：在查找过程中，会对查找表做出修改。 比如插入、删除。 静态查找 静态查找包括：顺序查找、二分查找、分块查找等。 顺序查找 查找表可以是有序或无序。 ...
二叉排序树（c++实现）
紫云的博客
04-16 4805
#include using namespace std; class btree { public: btree *left; btree *right; int data; btree(int i):left(NULL),right(NULL),data(i){} ~btree(); void insert(int a); static void inorder(
C++——算法基础之动态查找表2——平衡二叉树（插入）
暮雨灬倾晨~~~的博客
09-07 1355
C++ 动态查找树 平衡二叉树
C++数据结构之查找——静态查找表（顺序查找、折半查找、分块查找 带有gif以及图示）
m0_56398315的博客
09-15 6048
本文对查找进行介绍并对静态查找进行重点解释和实现，附有GIF动图以及相关图示方便读者进行阅读
【C/C++】查找（一）：静态查找表
weixin_30911809的博客
05-31 276
　　{静态查找表 + 动态查找表} 　　　　所谓动态，就是，找的时候没有则添加，或者能删除 　　关键字：primary key：用来表示查找表中的一条记录 　　　　{主关键字 + 次关键字} 　　　　主关键字是唯一的，用来唯一的标识查找表中的一条记录 （一）静态查找表 一、顺序表 　　类似于数组，顺序存储，在表中有位置，查找即给定关键字，遍历这个表，找到其位置或给出整条记录；...
软件技术基础学习课件-二叉排序树查找算法
本课程还将讲解二叉排序树的查找算法，为学生提供了二叉排序树的基本知识。 五、课程教学大纲 本课程的教学大纲如下： * 第1页：课程简介 * 第2页：课程内容和学时安排 * 第3页：教材 * 第4页：教学内容和教材...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值