查找算法之二叉查找树

最新推荐文章于 2021-05-20 18:15:22 发布
最新推荐文章于 2021-05-20 18:15:22 发布
阅读量375 收藏
点赞数
分类专栏： 算法 文章标签： 二叉查找树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wf131410000/article/details/48092251
版权

一  基本概念

由于线性表的查找算法对动态操作的支持效率很低，因此将几种特殊的树或者二叉树作为表的一种组织方式。

二叉树查找树非空树的话，具有下列性质：

（1）若它的左子树非空，则左子树上所有的结点的值均小于根结点的值。

（2）若它的右子树非空，则右子树上所有的结点的值均大于根结点的值。

（3）左子树和右子树又均为一颗二叉查找树。

其实，二叉查找树的中序遍历是一个有序序列。 


二  基本操作

取二叉链表作二叉查找树的存储结构。

1.结点定义：

class node
{
public:
	node()
	{
		rightchild = nullptr;
		leftchild = nullptr;
		value = 0;
	}
	~node(){}

private:
	int value;
	node* rightchild;
	node* leftchild;
};

2.二叉树表定义：

class tree
{
	friend ostream& operator<<(ostream& out,tree& list);
public:
	tree():head(nullptr){}
	~tree(){}
private:
	node* head;
public:
	void create();   //生成二叉树表
	void find(int val); //查找
	void erase(int val);//删除
	void insert(int val);//插入
private:
	void InOrder(node* d); //中序遍历，用来辅助输出
	node* find(node* ptr, int val);
	int erasenode(node* ptr, int val);
	void insert(node*& ptr, int val);
};

3. 二叉查找树的生成：

用任意一关键字序列构造二叉查找树，其实是对这一序列数进行排序，所以二叉查找树又称为二叉排序树。

void tree::create()
{

	int num;
	cout << "输入数据" << endl;
	while (cin >> num)
	{
		if (head == nullptr)
		{
			head = new node;
			head->value = num;
		}
		else
			insert(head, num);
	}

}


4.插入算法：

（1）若二叉查找树为空，则使新插入的结点为根结点插入树中。


（2）若二叉查找树不为空，则将带插入结点的关键字值与根节点的关键字值相比较，若插入的元素值小于根节点值，则将元素插入到左子树中。若插入的元素值不小于根节点值，则将元素插入到右子树中。

void tree::insert(node*& ptr, int val)
{
	if (ptr == nullptr)
	{
		ptr = new node;
		ptr->value = val;
	}
	else
	{
		if (val > ptr->value)
			insert(ptr->rightchild, val);
		else
			insert(ptr->leftchild, val);
	}
}

5.查找算法：

（1）若二叉查找树为空，查找失败。

（2）若二叉查找树根节点的关键值与查找值相等，查找成功。

（3）若查找的元素值小于根节点值，则在左子树中查找。

（4）若插入的元素值不小于根节点值，则在右子树中查找。


（1）递归查找：

node* tree::find(node* ptr, int val)
{
	if (ptr == nullptr)        //查找失败
		return nullptr;
	else
	{
		if (ptr->value == val)  //查找成功
			return ptr;
		else
		{
			if (val > ptr->value)        
				return find(ptr->rightchild, val);    //在右子树查找
			else
				return find(ptr->leftchild, val);     //在左子树查找
		}
	}
}

（2）非递归查找

node* tree::find(node* ptr, int val)
{
	if (ptr == nullptr)           //查找失败
		return nullptr;
	else
	{
		while (ptr)           
		{

			if (ptr->value == val)     //查找成功，跳出循环
				break;
			else
			{
				if (val > ptr->value)
					ptr = ptr->rightchild;
				else
					ptr = ptr->leftchild;
			}
		}

		if (ptr == nullptr)    //查找失败
			return nullptr;
		else
			return ptr;          //查找成功，返回结点信息
	}
}

6.删除算法：

删除点p分三种情况讨论：
（1）删除结点p为叶子节点，直接删除该节点，再修改其父节点的指针（注意分是根节点和不是根节点）。
（2）删除结点p为单支节点（即只有左子树或右子树），让p的子树与p的父亲节点相连，删除p即可。
（3）删除结点p的左子树和右子树均不空，找到p的直接前驱（或直接后驱）s,利用s代替p，再删除s。（将二叉查找树中序遍历后，看到顺序序列后就知道直接前驱和直接后驱）

int tree::erasenode(node* ptr,int val)
{
	node* temp = ptr;
	node* ps = nullptr;
	while (temp)                 //查找待删除结点
	{
		if (temp->value == val)   //查找成功
			break;
		else
		{
			if (val > temp->value)
			{
				ps = temp;                 //记录父节点
				temp = temp->rightchild;
			}
			else
			{
				ps = temp;
				temp = temp->rightchild;
			}
		}
	}
	 
	if (temp == nullptr)    //没找到
		return 0;
	if (temp->rightchild == nullptr&&temp->leftchild == nullptr)  //待删除结点是叶子结点
	{
		if (temp == ptr)
			ptr = nullptr;
		else
		{
			if (temp == ps->leftchild)
				ps->leftchild = nullptr;
			else
				ps->rightchild = nullptr;
		}
	}

	else if ((temp->leftchild == nullptr) || (temp->rightchild == nullptr)) //待删除结点仅有左孩子或右孩子
	{
		if (temp == ptr)
		{
			if ((temp == ps->leftchild) && (temp->leftchild != nullptr))
			{
				ps->leftchild = temp->leftchild;
			}
			else if ((temp == ps->leftchild) && (temp->rightchild != nullptr))
			{
				ps->leftchild = temp->rightchild;
			}
			else if ((temp == ps->rightchild) && (temp->rightchild != nullptr))
			{
				ps->rightchild = temp->rightchild;
			}
			else if ((temp == ps->rightchild) && (temp->leftchild != nullptr))
			{
				ps->rightchild = temp->leftchild;
			}

		}
	}

	else if ((temp->leftchild != nullptr) && (temp->rightchild != nullptr)) //待删除结点同时有左孩子和右孩子
	{
		node* p = temp, *q = temp->leftchild;
		while(q->rightchild != nullptr)  //找到待删除结点的前驱
		{
			p = q;
			q = q->rightchild;
		}
		temp->value = q->value;         //待删除结点用直接前驱结点代替
		if (p == temp)
			temp->leftchild = q->leftchild;
		else
			p->rightchild = q->leftchild;
		delete q;                      //删除前驱结点代替待删除结点
	}

	return 1;                       //表示已找到要删除的结点，并成功删除
}

7.附件：

完整版程序：

#include<iostream>
#include<string>
using namespace std;


class node
{
	friend class tree;
public:
	node()
	{
		rightchild = nullptr;
		leftchild = nullptr;
		value = 0;
	}
	~node(){}

private:
	int value;
	node* rightchild;
	node* leftchild;
};

class tree
{
	friend ostream& operator<<(ostream& out,tree& list);
public:
	tree():head(nullptr){}
	~tree(){}
private:
	node* head;
public:
	void create();   //生成二叉树表
	void find(int val); //查找
	void erase(int val);//删除
	void insert(int val);//插入
private:
	void InOrder(node* d); //中序遍历，用来辅助输出
	node* find(node* ptr, int val);
	int erasenode(node* ptr, int val);
	void insert(node*& ptr, int val);
};
void tree::erase(int val)
{
	if (1 == erasenode(head, val))
		cout << "删除成功" << endl;
	else
		cout << "删除失败" << endl;
}
void tree::insert(int val)
{
	insert(head, val);
}
void tree::find(int val)
{
	node* temp = find(head, val);
	if (temp == nullptr)
		cout << "查找失败" << endl;
	else
		cout << "查找成功" << endl;
}

ostream& operator<<(ostream& out, tree& list)
{
	list.InOrder(list.head);
	//cout << endl;
	return out;
}

void tree::InOrder(node* d)
{
	if (d)
	{
		InOrder(d->leftchild);
		cout << d->value <<" ";
		InOrder(d->rightchild);
	}
}
void tree::create()
{

	int num;
	cout << "输入数据" << endl;
	while (cin >> num)
	{
		if (head == nullptr)
		{
			head = new node;
			head->value = num;
		}
		else
			insert(head, num);
	}

}
void tree::insert(node*& ptr, int val)
{
	if (ptr == nullptr)
	{
		ptr = new node;
		ptr->value = val;
		ptr->leftchild = nullptr;
		ptr->rightchild = nullptr;
	}
	else
	{
		if (val > ptr->value)
			insert(ptr->rightchild, val);
		else
			insert(ptr->leftchild, val);
	}
}


/*node* tree::find(node* ptr, int val)
{
	if (ptr == nullptr)        //查找失败
		return nullptr;
	else
	{
		if (ptr->value == val)  //查找成功
			return ptr;
		else
		{
			if (val > ptr->value)        
				return find(ptr->rightchild, val);    //在右子树查找
			else
				return find(ptr->leftchild, val);     //在左子树查找
		}
	}
}*/


node* tree::find(node* ptr, int val)
{
	if (ptr == nullptr)           //查找失败
		return nullptr;
	else
	{
		while (ptr)           
		{

			if (ptr->value == val)     //查找成功，跳出循环
				break;
			else
			{
				if (val > ptr->value)
					ptr = ptr->rightchild;
				else
					ptr = ptr->leftchild;
			}
		}

		if (ptr == nullptr)    //查找失败
			return nullptr;
		else
			return ptr;          //查找成功，返回结点信息
	}
}


int tree::erasenode(node* ptr,int val)
{
	node* temp = ptr;
	node* ps = nullptr;
	while (temp)                 //查找待删除结点
	{
		if (temp->value == val)   //查找成功
			break;
		else
		{
			if (val > temp->value)
			{
				ps = temp;                 //记录父节点
				temp = temp->rightchild;
			}
			else
			{
				ps = temp;
				temp = temp->rightchild;
			}
		}
	}
	 
	if (temp == nullptr)    //没找到
		return 0;
	if (temp->rightchild == nullptr&&temp->leftchild == nullptr)  //待删除结点是叶子结点
	{
		if (temp == ptr)
			ptr = nullptr;
		else
		{
			if (temp == ps->leftchild)
				ps->leftchild = nullptr;
			else
				ps->rightchild = nullptr;
		}
	}

	else if ((temp->leftchild == nullptr) || (temp->rightchild == nullptr)) //待删除结点仅有左孩子或右孩子
	{
		if (temp == ptr)
		{
			if ((temp == ps->leftchild) && (temp->leftchild != nullptr))
			{
				ps->leftchild = temp->leftchild;
			}
			else if ((temp == ps->leftchild) && (temp->rightchild != nullptr))
			{
				ps->leftchild = temp->rightchild;
			}
			else if ((temp == ps->rightchild) && (temp->rightchild != nullptr))
			{
				ps->rightchild = temp->rightchild;
			}
			else if ((temp == ps->rightchild) && (temp->leftchild != nullptr))
			{
				ps->rightchild = temp->leftchild;
			}

		}
	}

	else if ((temp->leftchild != nullptr) && (temp->rightchild != nullptr)) //待删除结点同时有左孩子和右孩子
	{
		node* p = temp, *q = temp->leftchild;
		while(q->rightchild != nullptr)  //找到待删除结点的前驱
		{
			p = q;
			q = q->rightchild;
		}
		temp->value = q->value;         //待删除结点用直接前驱结点代替
		if (p == temp)
			temp->leftchild = q->leftchild;
		else
			p->rightchild = q->leftchild;
		delete q;                      //删除前驱结点代替待删除结点
	}

	return 1;                       //表示已找到要删除的结点，并成功删除
}

int main()
{
	tree lst;
	lst.create();
	cout << lst << endl;
	lst.find(10);
	lst.erase(5);
	cout << lst << endl;

	lst.insert(18);
	cout << lst << endl;
	system("pause");
	return 0;
}






朝来寒雨晚来风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉排序树序列判定
Bing's Blog
10-19 1万+
二叉排序树序列判定设二叉排序树中，关键字由1到1000的整数构成，现要查询关键字为363的结点，下述关键字序列中不可能是在二叉排序树上查找的序列是（C）A. 2,252,401,398,330,344,397,363 B. 924,220,911,244,898,258,362,363 C. 925,202,911,240,912,245,363 D. 2,399,387,219,266,38
Ruby实现的最优二叉查找树算法
01-21
算法导论上的伪码改写而成，加上导论的课后练习第一题的解的构造函数。 代码如下: #encoding: utf-8 =begin author: xu jin date: Nov 11, 2012 Optimal Binary Search Tree to find by using EditDistance ...
二叉搜索树BST
aitie1479的博客
01-01 162
二叉搜索树（英语：Binary Search Tree），也称二叉查找树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 任意节点...
【数据结构】二叉搜索树
weixin_34259559的博客
06-05 73
● 二叉搜索树满足以下条件的二叉树： 1、每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。2、左子树上所有节点的关键码（key）都小于根节点的关键码（key）。3、右子树上所有节点的关键码（key）都大于根节点的关键码（key）。4、左右子树都是二叉搜索树。● 二叉搜索树的插入过程如下：1、若当前的二叉搜索树为空，则插入的元素为根节点。2、若插入的元...
[LeetCode] Convert Sorted List to Binary Search Tree 将有序链表转为二叉搜索树
weixin_33858336的博客
12-04 85
Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST. 这道题是要求把有序链表转为二叉搜索树，和之前那道Convert Sorted Array to Binary Search Tree ...
二叉查找树的插入
qq_22080999的博客
06-20 227
#include&lt;iostream&gt; #include&lt;vector&gt; using namespace std; struct TreeNode { int val; TreeNode* left, *right; TreeNode(int x) :val(x), left(NULL), right(NULL){} }; void BST_insert(TreeNo...
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉查找树详细介绍.docx
最新发布
06-27
二叉查找树（BST，Binary Search Tree）是一种特殊类型的二叉树，它的每个节点都遵循以下规则： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点的值都大于该节点的值。 3. 左右子树也...
二叉查找树
01-20
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都遵循以下特性： 1. 节点的左子树仅包含比该节点小的节点。 2. 节点的右子树仅包含比该节点大的节点。 3. 左右子树也必须分别是...
数据结构-二叉搜索树的插入
YuebingXu的博客
02-14 275
数据结构-二叉搜索树插入算法 BinTree Insert(ElementType X, BinTree BST) { if ( !BST ) { /* 若原树为空，生成并返回一个节点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TreeNode)); BST-&amp;gt;Data...
刷题笔记（1） 一个序列是否为二叉搜索树的遍历结果
开到荼蘼的博客
03-26 225
1.输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 二叉搜索树：具体定义：https://blog.csdn.net/zj1131190425/article/details/88654541 是一棵二叉树，可能为空，非空的二叉搜索树满足以下特征： 1.每个元素都有唯一的关键字 2.根节点的左子树中...
数据结构笔记8 二叉搜索树（查找、插入、删除）
Lora青蛙的博客
08-14 402
（笔记总结自浙江大学数据结构MOOC） 文章目录二叉搜索树的概念二叉搜索树的查找二叉搜索树的插入二叉搜索树的删除 二叉搜索树的概念 二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树。 二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质： 非空左子树的所有键值小于其根结点的键值。 非空右子树的所有键值大于其根结点的键值。 左、右子树都是二叉搜索树。 二叉搜索树操作的特别函数： Position Find( ElementType X, BinTree BST
DFS算法之有序序列链表转换为平衡二叉搜索树
qq_40133908的博客
04-17 194
题目简介：上一篇做了无序序列链表的元素转换为平衡二叉搜索树，而这次的是有序的，这样来说要相对来说简单蛮多，因为要将有序的进行转换树，每个节点的值直接去数组中的中位数，然后利用分治法进行转换树。这样来说，可以直接将无序的链表转化为有序的，再进行转换为树，这样就会简单蛮多。。。。。。那么上一篇的就做麻烦了。。。。 实现思路上面已经说到了，利用分治法可以进行求解。只不过要注意一些细节，中位数如何取，最...
数据结构之三（二叉查找树）
onyheart的专栏
11-09 436
查找树是一种动态数据结构，支持插入、删除、查找等操作。 二叉查找树的复杂度和树的高度是成正比的。有n个节点的完全二叉树，树高为O(lgn)。但是如果树含义n个节点，如果为斜的，则成为链表，高度为O(n)。 1.        二叉查找树 每个节点最多有两个分支。对于每个节点。左孩子的任何节点小于根，根小于右孩子的任何节点。 2.        二叉排序 与快排的比较。 二叉排序，使用将
109. Convert Sorted List to Binary Search Tree（有序链表转换二叉搜索树）
God_Mood的博客
03-20 279
题目链接：https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/ 方法一： 思路，先把链表转化为数组，然后利用108题的解法。 AC 1ms Java： /** * Definition for singly-linked list. * public class ListNode { * ...
算法导论-7.二叉查找树
dayuan5183的博客
01-09 144
树几乎是使用最广泛地数据结构之一了，我想其原因是，在期望高度仅为 $lg n$ 的结构中存储了 $n$ 个元素。树中的每个操作，在每一层都使用了极具有价值的判断并降低了问题的复杂度，这几乎完美地体现了分治的思想。还有，从这篇博文开始，我开始用svg作为示意图而不是以前使用的png，这东西很符合我的……，呃，“理念”，唯一的问题就是创建起来有点麻烦……嗯。 二叉查找树 二叉查找树是一种...
二叉查找树（BST）
02-04 1065
1.定义 二叉查找树( Binary Search Tree,BST)是一种特殊的二叉树,又称为排序二叉树、二叉搜索树、二叉排序树。二叉査找树的递归定义如下： ①要么二叉査找树是一棵空树。 ②要么二叉查找树由根结点、左子树、右子树组成，其中左子树和右子树都是二叉查找树，且左子树上所有结点的数据域均小于或等于根结点的数据域，右子树上所有结点的数据域均大于根结点的数据域。 从二叉査找树的定义中...
【数据结构】二叉线索树插入元素的三种方法
allensu374125056的博客
05-04 959
二叉线索树插入元素的四种方法关于函数间接修改指针值递归返回节点递归返回void循环插入 临时变量为二级指针循环插入 临时变量为一级指针 关于函数间接修改指针值 树的遍历不涉及子叶的修改 所以不用考虑返回值和指针的问题 链表的逆序一般用的是循环 所以也不用考虑 char p[15] = "abcdef"; char p2[15] = "1235abcdef"; void change(char**...
c语言二叉树搜索函数,C语言实现二叉树的搜索及相关算法示例
weixin_39962199的博客
05-20 330
本文实例讲述了C语言实现二叉树的搜索及相关算法。分享给大家供大家参考，具体如下：二叉树(二叉查找树)是这样一类的树，父节点的左边孩子的key都小于它，右边孩子的key都大于它。二叉树在查找和存储中通常能保持logn的查找、插入、删除，以及前驱、后继，最大值，最小值复杂度，并且不占用额外的空间。这里演示二叉树的搜索及相关算法：#include#includeusing namespace std;c...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值