二叉搜索树的性质与实现

最新推荐文章于 2023-08-24 16:48:33 发布
最新推荐文章于 2023-08-24 16:48:33 发布
阅读量637 收藏
点赞数
分类专栏： c/c++ 算法 文章标签： c++ 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglifu081022/article/details/16285385
版权

二叉搜索树是一种特殊的二叉树，对于其中的任意一个节点z，如果其存在左子树，则其左子树存储的关键字值最大不超过z所存储的关键字值；如果其存在右子树，则其右子树存储的关键字值最小不小于z所存储的关键字值。对于相同的关键字集合，可以有不同的二叉搜索数构型。如下图所示都是二叉搜索树：



二叉搜索数拥有许多特殊的性质，下面就以其性质与一些属性为主线，实现一个基本的二叉搜索树。首先，定义一个头文件如下：

#ifndef __BinarySearchTree_H_
#define __BinarySearchTree_H_

#include <iostream>

using namespace std;

template<class Type>
struct tagTreeNode
{
	Type			Data;
	tagTreeNode*	Parent;
	tagTreeNode*	LeftChild;
	tagTreeNode*	RightChild;
	tagTreeNode() : Data(Type()) , Parent(NULL) , LeftChild(NULL) , RightChild(NULL) {}
};

template<class Type>
class BinarySearchTree
{
public:
	typedef	tagTreeNode<Type>		TreeNode;
	typedef tagTreeNode<Type>*		PTreeNode;

public:
	BinarySearchTree();
	~BinarySearchTree();

	void			AddNode(Type data);
	bool			Delete(Type data);
	bool			Delete(PTreeNode pNode);
	PTreeNode		Find(Type data);
	bool			HasNode(Type data);

	void			ResetTree();

	void			PreOrderTreeWalk();
	void			InOrderTreeWalk();
	void			PostOrderTreeWalk();

	PTreeNode		TreeMaxmum();
	PTreeNode		TreeMinmum();
	PTreeNode		TreeMaxmum(PTreeNode pNode);
	PTreeNode		TreeMinmum(PTreeNode pNode);
	PTreeNode		TreePredecessor(PTreeNode pNode);	//前驱
	PTreeNode		TreeSuccessor(PTreeNode pNode);	//后继

private:
	void			Destory();
	void			_Destory(PTreeNode pNode);
	void			_PreOrderTreeWalk(PTreeNode pNode);
	void			_InOrderTreeWalk(PTreeNode pNode);
	void			_PostOrderTreeWalk(PTreeNode pNode);
	void			TransPlant(PTreeNode src , PTreeNode dst);

private:
	PTreeNode	m_Root;
};
#endif __BinarySearchTree_H_

该头文件使用了简单的模板，先定义了一个结构体tagTreeNode来表示树的节点，其有四个数据，一个存储关键字，其余三个指向本结构体指针分别表示父结点、左孩子结点、右孩子结点。如果指向不存在则为NULL（VS2008没有C++11中的空指针）。定义了一个类BinarySearchTree来表示二叉搜索树，该类只定义了一个指向根结点的结构体指针。


1、插入与查找：设x是二叉搜索树中的一个结点，如果y是x左子树中的一个结点，那么y.data ≤ x.data 。如果y是x右子树中的一个 结点，那么 y.data ≥ x.data。

根据这个性质，我们可以构造一个二叉搜索树，定义向二叉搜索树中增加结点如下：

template<class Type>
void BinarySearchTree<Type>::AddNode(Type data)
{
	cout<<"Add node "<<data<<endl;
	PTreeNode pNewNode = new TreeNode;
	pNewNode->Data = data;

	PTreeNode pParent = NULL;
	PTreeNode pNode = m_Root;
	while(pNode)
	{
		pParent = pNode;
		if(pNode->Data > data)
			pNode = pNode->LeftChild;
		else
			pNode = pNode->RightChild;
	}

	if(pParent == NULL)
	{
		pNewNode->Parent = NULL;
		m_Root = pNewNode;
	}
	else
	{
		pNewNode->Parent = pParent;
		if(pParent->Data > data)
			pParent->LeftChild = pNewNode;
		else
			pParent->RightChild = pNewNode;
	}
}

我们先把要增加的结点生成出来，再放到适当的位置。第一个while循环查找位置：如果当前结点的值比要插入结点的值大则继续在其左子树中查找，否则在右子树中查找，直到符合该性质的空尾，保留可以插入的位置的父结点以便插入。


同理，根据这个性质，我们可以很容易的在一棵二叉搜索树中查找一个值、一个结点是否存在或实现定位。

template<class Type>
tagTreeNode<Type>* BinarySearchTree<Type>::Find(Type data)
{
	PTreeNode pNode = m_Root;
	while(pNode && pNode->Data != data)
	{
		if(pNode->Data > data)
			pNode = pNode->LeftChild;
		else
			pNode = pNode->RightChild;
	}

	return pNode;
}

template<class Type>
bool BinarySearchTree<Type>::HasNode(Type data)
{
	PTreeNode pNode = Find(data);
	if(pNode != NULL)
	{
		cout<<"Has Node "<<data<<endl;
		return true;
	}
	else
	{
		cout<<"Do Not Have Node "<<data<<endl;
		return false;
	}
}
当然，可以更简单的实现递归版的查找功能，但是循环版的在性能上来说更好一点。

2、遍历：如果x是一颗有n个结点子树的根，那么中序遍历该树需要Θ(n)时间。

我们这里不去证明该定理，而是去实现中序、先序、后序遍历。谈到二叉树，就必须了解它的三种遍历方式。所谓中序遍历即：先遍历某个结点，再去遍历它的左子树的结点，然后去遍历它的右子树的结点。其实这三种遍历区别在于哪个时候访问当前结点的值。

由于这种遍历的方式，让人很自然就想到用递归去遍历，这里也是这样实现的：

template<class Type>
void BinarySearchTree<Type>::InOrderTreeWalk()
{
	_InOrderTreeWalk(m_Root);
	cout<<endl;
}

template<class Type>
void BinarySearchTree<Type>::_InOrderTreeWalk(PTreeNode pNode)
{
	if(pNode == NULL)
		return;
	_InOrderTreeWalk(pNode->LeftChild);
	cout<<pNode->Data<<"  ";
	_InOrderTreeWalk(pNode->RightChild);
}

第一个函数只是传递树根调用第二个函数。第二个函数是中序遍历的递归实现：如果当前结点为空，则立即返回，这是跳出递归的必须条件。先遍历左子树，如果其左子树不为空，则又会用同样的方法递归遍历其左子树，如果做子树为空，则会遇到跳出条件理解返回。访问当前结点的值，再遍历其右子树。同理，先序遍历和有序遍历基本相同： 

template<class Type>
void BinarySearchTree<Type>::PreOrderTreeWalk()
{
	_PreOrderTreeWalk(m_Root);
	cout<<endl;
}

template<class Type>
void BinarySearchTree<Type>::PostOrderTreeWalk()
{
	_PostOrderTreeWalk(m_Root);
	cout<<endl;
}

template<class Type>
void BinarySearchTree<Type>::_PreOrderTreeWalk(PTreeNode pNode)
{
	if(pNode == NULL)
		return;
	cout<<pNode->Data<<"  ";
	_PreOrderTreeWalk(pNode->LeftChild);
	_PreOrderTreeWalk(pNode->RightChild);
}

template<class Type>
void BinarySearchTree<Type>::_PostOrderTreeWalk(PTreeNode pNode)
{
	if(pNode == NULL)
		return;
	_PostOrderTreeWalk(pNode->LeftChild);
	_PostOrderTreeWalk(pNode->RightChild);
	cout<<pNode->Data<<"  ";
}

3、搜索：对于一棵高度为h的二叉搜索树，要查找最大/最小关键值元素总能再O(h)时间内完成。

所谓最大关键值元素即在某一棵不为空的二叉搜索棵树中，其存储的值不比树中其他存储的值小。我们可以根据数的特性，一直搜索一个数的右子树来实现，即如果以z为根的二叉搜索数，如果其存在右子树，则最大关键值元素一定在其右子树中。同理，如果该树存在左子树，则其最小关键值元素一点存在其左子树中。如果不存在子树，则为其本身。

template<class Type>
tagTreeNode<Type>* BinarySearchTree<Type>::TreeMaxmum()
{
	return TreeMaxmum(m_Root);
}

template<class Type>
tagTreeNode<Type>* BinarySearchTree<Type>::TreeMinmum()
{
	return TreeMinmum(m_Root);
}

template<class Type>
tagTreeNode<Type>* BinarySearchTree<Type>::TreeMaxmum(PTreeNode pNode)
{
	while(pNode && pNode->RightChild)
		pNode = pNode->RightChild;

	return pNode;
}

template<class Type>
tagTreeNode<Type>* BinarySearchTree<Type>::TreeMinmum(PTreeNode pNode)
{
	while(pNode && pNode->LeftChild)
		pNode = pNode->LeftChild;

	return pNode;
}


4、前驱和后继：

要查找前驱，则根据二叉搜索树的性质，可以分为两种情形：

a、如果结点x的左子树非空，则其前驱为其左子树的最大关键值结点。

b、如果结点x的左子树为空，则其前驱为沿该结点向上，第一个不为左孩子的结点的父结点。当然，这种情形前驱可能不存在。

template<class Type>
tagTreeNode<Type>* BinarySearchTree<Type>::TreePredecessor(PTreeNode pNode)
{
	if(pNode->LeftChild)
		return TreeMaxmum(pNode->LeftChild);

	PTreeNode pParent = pNode->Parent;
	while(pParent && pNode == pParent->LeftChild)
	{
		pNode = pParent;
		pParent = pNode->Parent;
	}

	return pParent;
}
如上面的第一幅图，值为2的结点一直往上查找第一个不为左孩子的结点，但是不存在，所有其前驱不存在。值为8的结点向上查找这样的结点，找到了值为7的结点，所有值为7的结点即为其前驱。第二棵二叉搜索树中， 深度为5的值为5的结点一直向上查找，找到7为第一个不为左孩子的结点，且其父结点存在，则其父结点（深度为2的值为5的结点）即为要找的前驱。


要查找后继，我们有如下策略：

a、如果结点存在右孩子，则其后继为其右孩子为根节点的子树的最小关键字结点。

b、如果结点不存在有孩子，则其后继为沿父结点往上查找，第一个不为右孩子的结点的父结点。也可能不存在。

template<class Type>
tagTreeNode<Type>* BinarySearchTree<Type>::TreeSuccessor(PTreeNode pNode)
{
	if(pNode->RightChild)
		return TreeMinmum(pNode->RightChild);

	PTreeNode pParent = pNode->Parent;
	while(pParent && pNode == pParent->RightChild)
	{
		pNode = pParent;
		pParent = pNode->Parent;
	}

	return pParent;
}


5、删除结点

删除结点比较复杂，可以分以下情形：

a、如果z没有左孩子（包括有右孩子和没有孩子结点的情形），那么用其右孩子来替换z，这个右孩子可以是NULL，也可以不是。

b、如果z仅有一个孩子且为其左孩子，则用其左孩子来替换z。

c、如果z同时存在两个孩子，则需要查找其后继y，做如下操作：

    1) 如果y是z的右孩子，则用y替换z，仅保留y的右孩子。

    2) 用y的右孩子替换y，然后用y替换z。


如上图为各种删除的情形，其中实现为父子关系，虚线表示中间可能间隔多个结点相连。程序实现如下

template<class Type>
bool BinarySearchTree<Type>::Delete(PTreeNode pNode)
{
	if(! pNode)
		return false;
	if(NULL == pNode->LeftChild)	// two case:1.left and right child both are NULL. 2.left child is NULL,and right child is not NULL
	{
		TransPlant(pNode , pNode->RightChild);	//make his right child or NULL to replace his position
		delete pNode;
		return true;
	}
	else if(NULL == pNode->RightChild)	//left child is not NULL and right child is NULL
	{
		TransPlant(pNode , pNode->LeftChild);	//make his left child to replace his position
		delete pNode;
		return true;
	}
	else	//both children are not NULL
	{
		PTreeNode y = TreeMinmum(pNode->RightChild);
		if(y->Parent != pNode)
		{
			TransPlant(y , y->RightChild);
			y->RightChild = pNode->RightChild;
			y->RightChild->Parent = y;
		}
		TransPlant(pNode , y);
		y->LeftChild = pNode->LeftChild;
		y->LeftChild->Parent = y;
		delete pNode;
		return true;
	}
}

template<class Type>
void BinarySearchTree<Type>::TransPlant(PTreeNode src , PTreeNode dst)
{
	if(! src->Parent)
		m_Root = dst;
	else if(src == src->Parent->LeftChild)
		src->Parent->LeftChild = dst;
	else
		src->Parent->RightChild = dst;
	dst->Parent = src->Parent;
}
这里专门写了个函数TransPlant来处理用dst结点替换src结点的操作。


其他一些函数实现：

template<class Type>
BinarySearchTree<Type>::BinarySearchTree():
m_Root(NULL)
{
	
}

template<class Type>
BinarySearchTree<Type>::~BinarySearchTree()
{
	Destory();
}

template<class Type>
void BinarySearchTree<Type>::ResetTree()
{
	Destory();
	m_Root = NULL;
}

template<class Type>
void BinarySearchTree<Type>::Destory()
{
	_Destory(m_Root);
}

template<class Type>
void BinarySearchTree<Type>::_Destory(PTreeNode pNode)
{
	if(pNode == NULL)
		return;
	if(pNode->LeftChild)
		_Destory(pNode->LeftChild);
	if(pNode->RightChild)
		_Destory(pNode->RightChild);

	cout<<"delete node "<<pNode->Data<<endl;
	delete pNode;
}










zhanglifu081022
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树
CCPP Blog
07-05 4095
定义 二叉搜索树(Binary Search Tree)或称二叉查找树，也称二叉排序树(Binary Sort Tree)。它或者是一棵空树，或者是具有下列性质的二叉树： 若左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若右子树不空，则右子树上所有节点的值均大于它的根节点的值； 左、右子树也分别为二叉搜索树； 性质 二叉搜索树与普通二叉树相比，有一些优秀的特征或性质： 由于节点是有序排放的：左子树<根节点<右子树。故在查找一个节点的时候，只需先和根节点比较，再决定是进入左子树还是右子树查找。而
二叉搜索树的性质
u010005161的博客
05-28 2123
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树） 它或者是一棵空树，或者是具有下列性质的二叉树：  1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；  2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；  3. 它的左、右子树也分别为二叉排序树。 因此，若对它进行中序遍历，则是一颗递增的排好序的序列！ 这一点
算法笔记---二叉查找树的性质
、思考致富的博客
04-13 166
题目描述 给出N个正整数来作为一棵二叉排序树的结点插入顺序，问：这串序列是否是该二叉排序树的先序序列或是该二叉排序树的镜像树的先序序列。所谓镜像树是指交换二叉树的所有结点的左右子树而形成的树（也即左子树所有结点数据域大于或等于根结点，而根结点数据域小于右子树所有结点的数据域）。如果是镜像树，则输出YES，并输出对应的树的后序序列；否则，输出NO。 输入样例1 7 8 6 5 7 10 8 11 输...
二叉搜索树基本性质
qq_43434328的博客
01-28 666
二叉搜素树满足三个性质 1.任意节点的左子树若不为空，那么左子树上的所有节点均小于等于该节点的值 2.任意节点的右子树若不为空，那么右子树上的所有节点均大于等于该节点的值 3.任意节点的左右子树也均为二叉搜素树 ...
二叉搜索树（特性篇）
c630843901的博客
07-06 306
二叉搜索树并不算复杂，但我觉得它可以算是数据结构领域的半壁江山，直接基于 BST 的数据结构有 AVL 树，红黑树等等，拥有了自平衡性质，可以提供 logN 级别的增删查改效率；还有 B+ 树，线段树等结构都是基于 BST 的思想来设计的。从做算法题的角度来看 BST，除了它的定义，还有一个重要的性质：BST 的中序遍历结果是有序的（升序）。也就是说，如果输入一棵 BST，以下代码可以将 BST 中每个节点的值升序打印出来： 寻找第 K 小的元素 力扣第 230 题「 二叉搜索树中第 K 小的元素」 ，一个
二叉查找树的性质和用法
m0_51711089的博客
07-13 314
二叉查找树的定义：左子树都要小于或者等于根节点的数据域，右子树都要大于根节点的数据与。1.二叉查找树的寻找操作：该根节点的数据域大于x值，说明该结点的数据域大了，就该往左子树寻找进行递归。该根结点的数据域小于x值，说明该结点的数据域小了，就该往右子树寻找进行递归。root等于NULL的话说明寻找失败。代码: 一般的二叉树寻找，因为子树的数据域是无序的，没有选择，而二叉寻找树可以有选择地递归左右子树，且二叉寻找树的数据域大小排序是root->lchild->data < root->data ..
二叉搜索树的性质及Python实现（数据结构与算法4）
luluzsa的博客
03-02 539
1.二叉搜索树（BST）性质：小于父节点的键都在左子树中，大于父节点的键都在右子树中。 我们采用“节点与引用”表示法实现二叉搜索树，由于必须创建并处理一颗空的二叉搜索树，所以我们将使用两个类，一个为BinarySearchTree,另一个为TreeNode，具体实现代码如下。 class BinarySearchTree: def __init__(self): self.root=None self.size=0 def length(se
二叉搜索树性质与实现
飞扬的青春的专栏
08-27 1000
一、概念        搜索树
二叉树的性质及二叉查找树的实现
全村最靓的仔
08-31 394
二叉树的性质 树中的结点数等于数的边数加1，也等于所有的度数之和加1(此性质适合所有的树) 在二叉树的第i层上最多有2i2^i2i个结点，其中i从第0层开始 高度为h的二叉树至多有2h+1−12^{h+1}-12h+1−1个结点 对于任意一棵二叉树T，如果其终端节点数为n0，度为2的结点数为n2，则n0 = n2 + 1 (可以使用性质1来推导，n = n0 + n2 + n1 , n = ...
二叉树的性质以及二叉查找树的基本操作
jayxu无捷之径的博客
08-06 1649
1、基本概念 树（Tree）是n（n≥0）个结点的有限集。在任意一棵非空树中：（1）有且仅有一个特定的被称为根（Root）的结点；（2）当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1，T2，…，Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。 度：结点拥有的子树数称为结点的度（Degree）。度为0的结点称为叶子（Leaf）或终端结点。度不为0的结点称
搜索树基础：二叉搜索树（详解特性用途，图解实现过程）
最新发布
LEE180501的博客
08-24 2013
有兴趣学数据结构了吗？
深入学习理解二叉搜索树（附详细讲解与实例分析）
热门推荐
Hin 的博客
11-01 1万+
原创文章，转载请注明出处。本文主要分为三个部分。第一部分介绍了二叉搜索树的基本性质。第二部分全面详细地讲述了二叉搜索树的各种基本操作。第三部分则是完整的代码实现及实例分析。 对于每一种基本操作，都至少分三个重点进行讲解。它们分别是基本操作过程及原理（包含伪代码及C++实现）、时间复杂度分析以及举例分析（配图）。力求让每位读者可以直观地理解。 本文断断续续写了几天，各部分的举例分析也十分明了，为了讲得更清楚一些，所有的配图都是自行制作的。请尊重劳动成果，供人供己查阅，如有错误之处，欢迎
二叉搜索树的属性
m0_61452966的博客
11-27 215
一、二叉搜索树中的搜索 二、验证二叉搜索树 三、二叉搜索树的最小绝对差 四、二叉搜索树的众数 五、把二叉搜索树转换为累加树
二叉查找树、红黑树、B树性质
豆子的collection
12-16 1465
二叉查找树性质“： 1、遍历一棵含有n个节点的二叉查找树所需时间为Θ（n）（包括中序、前序、后续） 2、对一棵高度为h的二叉查找树，动态操作集合操作search、miniMum、maxiMum、successor和predecessor、insert、delete的运行时间均为Θ（n） 3、一棵在n个关键字上随机构造的二叉查找树的期望高度为O（lgn） 红黑树定义: 红黑
二叉排序树的性质
zrh_CSDN的博客
07-24 2371
1.若它的左子树不为空，则左子树上的所有节点的值均小于根节点的值； 2.若它的右子树不为空，则右子树上的所有结点的值均大于根节点的值； 3.二叉排序树的左右子树也都是二叉排序树。...
二叉搜索树性质及插入，删除，是否存在
qq_44331767的博客
04-22 219
二叉搜索树 又称二叉排序树，它或者是一颗空树 1.性质： 若他的左子树不为空，则左子树所有节点的值小于根节点的值 若他的右子树不为空，则有字数上所有节点都小于根节点的值 它的左右子树也分别为二叉搜索树 2.作用： 用来进行搜索 3.二叉搜索树注意事项： 进行中序遍历，可以得到一个有序的序列 树中最左侧节点一定是最小的节点，最右侧节点一定是最大的 4.常见操作 static class BSTn...
优化二叉搜索树：问题与概率影响
"最优二叉搜索树是一种特殊的二叉搜索树结构，旨在解决在实际应用中遇到的两个主要问题：检索失败的概率以及不同标识符的检索概率差异。首先，传统的二叉搜索树在处理数据时，如果数据分布不均匀或存在大量重复值，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值