二叉查找树的原理与实现

最新推荐文章于 2022-07-28 12:45:13 发布
最新推荐文章于 2022-07-28 12:45:13 发布
阅读量1k 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉查找树 算法 插入删除
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyongxue/article/details/16949759
版权

二叉查找树，又名二叉搜索树，主要性质：左孩子 < 父 < 右孩子，如果将二叉查找树按前序遍历输出的话，输出的序列则是由小到大的有序序列。

二叉查找树上的基本操作包括：search, minimum, maximum, predecessor, successor, insert, delete. 而这些操作基本所花费的时与这棵树的高度成正比。对于一棵完全树来说，这些操作的最坏运行时间为：O(lgn)，而对于n个结点连成一条线的树来说，则为O（n)。那如何才能保证所有的基本操作复杂度控制在O(lgn)呢？ 这在下一节中，我将给二叉查找树的变形体------>红黑树，B树。

下面分别介绍二叉查找树的相关操作：

（1）search:

 树的高度为h, 时间复杂度为O(h).

Tree_Search(root, k)

while root !=NULL and k!=root.data
    if k >root.data
        root = root.rchild
    else
        root = root.lchild

return root


(2)Minimum:

很容易知道，一棵二叉查找树的最小元素是它的最左端的叶子结点。很容易可以写出它的算法：

Tree_Minimum(root)

while(root !=NULL)
   x = root
   root = root.lchild

return x


(3)Maximum:

同理，可以知道maximum的算法

Tree_Minimum(root)

while(root !=NULL)
   x = root
   root = root.rchild

return x


(4)Successor:

查找一个二叉树结点的后继，即查找大小紧跟其后的一个结点。

如果，该结点存在右子树，则直接返回其右子树的最小元素 。反之，按照“左上-->左上-->在上--......-->右上”的线路寻找。

Tree_Successor( x )

if x.right != NULL
   return Minimum(x.right)
y = x.p
while(y!=NULL and x = y.right)
   x = y
   y = y.p

return y


（5）Predecessor:

与Successor的实现对称。如果该结点存在左子树，则直接返回其左子树的最大元素。反之，按照“右上--》右上---》。。。右上--》左上"的线路寻找

Tree_Predecessor( x )

if x.left!= NULL
   return Maximun(x.left)
y = x.p
while(y!=NULL and x = y.left)
   x = y
   y = y.p

return y


（6）Insert：

while(x!=NUll)
   y = x
   if(k<x.data)
      x = x.left
   else 
      x = x.right
 z.p = y
 if y  = NULL
     root = z
 if k<y.data
    y.left = z
 else 
    y.right = z


（7）delete:

 分情况讨论：被删除的结点为z

 #1、如果z没有左孩子，则直接删除z， 用其右孩子来代替

 #2、如果z只有左孩子，直接删除z，用其左孩子来代替

 #3、如果z同时存在双孩子，则用查找y的后继，。。。。

其实可以这样简单地考虑，要被删除的结点为z, 而实际上被删除的结点为y(它的后继结点），而删除之前，互换z和y结点的值，指针不变。如果z同时存在左孩子和右孩子。

Tree_delete(x, z)

if z.left = NULL or z.right = NULL
	y = z
else 
	y = z.Successor()
if y.left != NULL
	x = y.left 
else 
	x = y.right
#删除y,则用x为根的子树去替换它即可
p.x = p.y
if p.y == NULL
	root = x
else if y = y.p.left 
	    y.p.left = x
    
     else 
	    y.p.right = x

if y != z   #如果y和z不是同一个结点，则交换二者的元素值
	z.data = y.data



二叉查找树的简单实现：

// 二叉查找树.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

using namespace std;

typedef struct BITree
{
	int key;
	BITree *left;
	BITree *right;
	BITree *p;
}BITree;

BITree * Serach(BITree *root , int x)
{
	//用非递归的做法实现
	BITree *p = root;
	while(p!=NULL && x!=p->key)
	{
		if(x<p->key)
			p = p->left;
		else
			p = p->right;
	}
	return p;  //这时p可能为NULL,则说明没有查找到该关键字
}

BITree * SerachMin(BITree *root)
{
	BITree *p = root;
	while(p->left!=NULL)
	{
		p = p->left;
	}
	return p;

}

BITree * SerachMax(BITree *root)
{
	BITree *p = root;
	while(p->right!=NULL)
	{
		p = p->right;
	}
	return p;
}

//查找某结点的前驱
BITree *FindProcessor(BITree *Node)
{
	return NULL;
}

//查找某节点的后继，后继并非链表中所指，二叉树中的后继是关键字比它大的最小元素
//如果该结点的右子树非空，则直接返回右子树的最小结点
//如果该结点的右子树为空，则其后继为带有左孩子的最底层结点
BITree *FindSuccessor(BITree *Node)
{
	if(Node->right!=NULL)
		return SerachMin(Node->right);
	BITree *p = Node->p;
	while(p!=NULL && Node == p->right)
	{
		Node = p;
		p = p->p;
	}
	return p;

}

//
void insert(BITree *&root, int x)
{
	BITree *p = root;
	BITree *y = NULL;
	BITree *insertNode = new BITree;
	insertNode->key = x;
	insertNode->left = NULL;
	insertNode->right = NULL;
	while(p!=NULL)
	{
		y = p;
		if(x<p->key)
			p = p->left;
		else
			p = p->right;
	}
	insertNode->p = y;
	if(y == NULL) //即这是一棵空子树
		root = insertNode;
	else if(x<y->key)
		y->left = insertNode;
	else
		y->right = insertNode;
}

void TransParent(BITree *root, BITree *p, BITree *q)
{
	if(p->p == NULL) //p结点是root,那么直接将q置为root
		root = q;
	else if(p == p->p->left)
		p->p->left = q;
	else
		p->p->right = q;
	if(q!=NULL)
		q->p = p->p;


}
//Delete:有4种情况,令要删除的结点为pNode;
//1、pNode没有左孩子，那么直接用其右孩子代替它
//2、pNode只有左孩子，直接用左孩子代替它
//3、pNode既有左孩子，又有右孩子。那么查找它的后继，该结点是没有左孩子的。那么还应考虑该后继是它的右结点还只是右子树中的某个结点。
void deleteNode(BITree *&root,int x) //这里传二级指针是因为：删除结点可能改变root
{
	BITree * p = Serach(root,x);
	cout<<"Delete Node key:"<<p->key<<endl;
	if(p->left == NULL)
		TransParent(root,p,p->right);
	else if(p->right == NULL)
		TransParent(root,p,p->left);
	else
	{
		BITree *k = SerachMin(p->right);
		cout<<"Min Key"<<k->key<<endl;
		if(k != p->right)//如果该后继结点刚好是p的右孩子，那么将k替换p,此时p的左孩子成为k的左孩子，该左孩子的父亲即为k.
		{
			TransParent(root,k,k->right);
			k->right = p->right;
			k->right->p = k;
		}//如果该后 继结点不是p的右孩子，那么将k的右孩子转化为k,并成为其双亲的一个孩子。然后将p的右孩子变为y的右孩子。
		TransParent(root,p,k);
		k->left = p->left;
		k->left->p = k;
	}
}

/*void Create(BITree *root)
{
	int key;
	cout<<"input the node:";
	cin>>key;
	while(key!=0)
	{
		insert(root,key);
	}

}*/

void Create(int nodeArray[], int length, BITree *&root)
{
	int i;
	for(i = 0;i<length;i++)
	{
		insert(root,nodeArray[i]);
	}
}

void printInorder(BITree *root)
{
	BITree *p = root;
	if(p!=NULL)
	{
		printInorder(p->left);
		cout<<p->key<<' ';
		printInorder(p->right);
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int i;
	BITree *root =NULL;
	int nodeArray[11] = {15,6,18,3,7,17,20,2,4,13,9};
	Create(nodeArray,11,root);
	printInorder(root);
	deleteNode(root,15);
	printInorder(root);
	return 0;
}


二叉查找树的类模板实现 ：

// 二叉查找树类模板实现.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <stack>

using namespace  std;

template<class T>
struct _TreeNode
{
	T data;
	struct _TreeNode *p;
	struct _TreeNode *left;
	struct _TreeNode *right;
};


template<class T>
class SearchTree
{
private:
	typedef struct _TreeNode<T> TreeNode, *pTreeNode;
	TreeNode *root;

public:
	SearchTree();
	~SearchTree();

	void createSearchTree(T *s , int length);
	TreeNode * Minimum(TreeNode *pNode) const;
	TreeNode * Maximum(TreeNode *pNode) const;
	TreeNode * Search(T k);
	TreeNode * Successor(TreeNode *pNode) const;
	TreeNode * Predessor(TreeNode *pNode) const;
	TreeNode * _allocNode();
	void Insert_Node(TreeNode *pNode);
	void delete_Node(T k);
	void _printInOrder() const;

};


template<class T>
SearchTree<T>::SearchTree()
{
	root = _allocNode();
}

template<class T>
SearchTree<T>::~SearchTree()
{
	delete root;
	root = NULL;
}

template<class T>
typename SearchTree<T>::TreeNode * SearchTree<T>::_allocNode()
{
	TreeNode *newNode = new TreeNode;
	newNode->data = NULL;
	newNode->left = NULL;
	newNode->right = NULL;
	newNode->p = NULL;
	return newNode;
}

template<class T>
typename SearchTree<T>::TreeNode *SearchTree<T>::Search(T k)
{
	TreeNode *searchNode = root;
	while(searchNode!=NULL && k!=searchNode->data)
	{
		if(k<searchNode->data)
			searchNode = searchNode->left;
		else 
			searchNode = searchNode->right;
	}
	return searchNode;
}
//pNode表示寻找以它为根的子树的最小值
template<class T>
typename SearchTree<T>::TreeNode * SearchTree<T>::Minimum(TreeNode *pNode) const
{
	while(pNode->left )
	{
		pNode = pNode->left;
	}
	return pNode;
}

//pNode表示寻找以它为根的子树的最大值
template<class T>
typename SearchTree<T>::TreeNode * SearchTree<T>::Maximum(TreeNode *pNode) const
{
	while(pNode->right )
	{
		pNode = pNode->right
	}
	return pNode;
}

template<class T>
typename SearchTree<T>::TreeNode * SearchTree<T>::Successor(TreeNode *pNode) const
{
	if(pNode->right)
		return Minimum(pNode->right);
	TreeNode *y = pNode->p;
	while(y!=NULL && pNode == y->right)
	{
		pNode = y;
		y = y->p;
	}
	return y;
}

template<class T>
typename SearchTree<T>::TreeNode * SearchTree<T>::Predessor(TreeNode *pNode) const
{
	if(pNode->left)
		return Minimum(pNode->left);
	TreeNode *y = pNode->p;
	while(y!=NULL && pNode == y->left)
	{
		pNode = y;
		y = y->p;
	}
	return y;
}

template<class T>
void SearchTree<T>::Insert_Node(typename SearchTree<T>::TreeNode *insertNode)
{
	typename SearchTree<T>::TreeNode *x = root;
	typename SearchTree<T>::TreeNode *temp = NULL;
	while(x)
	{
		temp = x;
		if(insertNode->data < x->data)
			x = x->left;
		else
			x  = x->right;
	}
	insertNode->p = temp;
	if(!temp)
		root = insertNode;
	else if(insertNode->data<temp->data)
		temp->left = insertNode;
	else 
		temp->right = insertNode;
}
//用TNULL取代NULL,可以使用程序更加简洁
template<class T>
void SearchTree<T>::delete_Node(T k)
{
	typename SearchTree<T>::TreeNode *deleteNode = Search(k);
	typename SearchTree<T>::TreeNode *y = NULL;
	typename SearchTree<T>::TreeNode *x = NULL;
	if(deleteNode->left == NULL || deleteNode->right == NULL)
	{
		y = deleteNode;
	}
	else
		y = Successor(deleteNode);

	if(deleteNode!=y)
		deleteNode->data = y->data;	

	if(!y->left)
		x = y->left;
	else
		x = y->right;
	if(x != NULL)
	{
		x->p = y->p;
		if(y->p == NULL)
			root = x;
		else if(y = y->p->left)
			y->p->left = x;
		else
			y->p->right = x;
	}
	else
	{
		if(y = y->p->left )
			y->p->left = NULL;
		else
			y->p->right = NULL;
		delete y;
		y = NULL;
	}
}

//创建二叉树就是不断地插入新结点的过程
template<class T>
void SearchTree<T>::createSearchTree(T *s,int lenght) 
{
	root->data = s[0];
	for(int i = 1;i<lenght;i++)
	{
		typename SearchTree<T>::TreeNode *newNode = _allocNode();
		newNode->data = s[i];
		Insert_Node(newNode);
	}
}

/*template<class T>
void SearchTree<T>::printInorder(typename SearchTree<T>::TreeNode *pRoot) const
{
	if(pRoot!=NULL)
	{
		printInorder(pRoot->lchild);
		cout<<pRoot->data<<',';
		printInorder(pRoot->rchild);

	}
}*/

//中序非递归遍历
template<class T>
void SearchTree<T>::_printInOrder() const
{
	typedef struct _TreeNode<T> TreeNode;
	stack<TreeNode *> s;
	TreeNode *p = root;
	while(!s.empty() ||p!=NULL)
	{
		while(p!=NULL)
		{
			s.push(p);
			p = p->left;
		}

		if(!s.empty())
		{
			TreeNode *temp = s.top();
			s.pop();
			cout<<temp->data<<',';
			p = temp->right;
		}
	}
}


int _tmain(int argc, _TCHAR* argv[])
{
	SearchTree<int> *tree = new SearchTree<int>;
	int s[] = {15,2,4,3,7,6,18,17,20,13,9};
	tree->createSearchTree(s,11);
	tree->_printInOrder();
	cout<<endl<<"delete 15:"<<endl;
	tree->delete_Node(s[0]);
	tree->_printInOrder();
	return 0;
}







cyxHehui
关注
专栏目录
深入学习理解二叉搜索树（附详细讲解与实例分析）
Hin 的博客
11-01 1万+
原创文章，转载请注明出处。本文主要分为三个部分。第一部分介绍了二叉搜索树的基本性质。第二部分全面详细地讲述了二叉搜索树的各种基本操作。第三部分则是完整的代码实现及实例分析。 对于每一种基本操作，都至少分三个重点进行讲解。它们分别是基本操作过程及原理（包含伪代码及C++实现）、时间复杂度分析以及举例分析（配图）。力求让每位读者可以直观地理解。 本文断断续续写了几天，各部分的举例分析也十分明了，为了讲得更清楚一些，所有的配图都是自行制作的。请尊重劳动成果，供人供己查阅，如有错误之处，欢迎
二叉查找树的原理及实现
qq_39747794的博客
11-01 1193
前言 学习了一些数据结构之后，你是不是已经有些小得意了，以为数据结构就这点东西嘛，不就用好栈、队列什么什么的就好，呵呵，那些只是皮毛。接下来的东西才会让你真正认识到数据结构的博大精深，当你看到接下来那些酷炫狂赛的操作时，你会惊叹于数据结构的神奇。在学习那些酷炫的AVL树，红黑树之前，我们先入个门，学习最简单的动态查找表——二叉查找树。 二叉查找树 二叉查找树有被称为二叉排序树，它要么是个空树...
二叉查找树实现原理分析
aikuangchou2298的博客
04-08 206
引言 二叉查找树是一种能将链表插入的灵活性和有序数组查找的高效性结合起来的一种重要的数据结构，它是我们后面学习红黑树和AVL树的基础，本文我们就先来看一下二叉查找树的实现原理。 二叉查找树的定义 二叉查找树最重要的一个特征就是：每个结点都含有一个Comparable的键及其相关联的值，该结点的键要大于左子树中所有结点的键，而小于右子树中所有结点的键。 下图就是一个典型的二叉查找...
二叉搜索树原理
牛牛码特的博客
06-20 164
二叉搜索树（BST）又称二叉查找树或二叉排序树。一棵二叉搜索树是以二叉树来组织的，可以使用一个链表数据结构来表示，其中每一个结点就是一个对象。一般地，除了key和卫星数据之外，每个结点还包含属性lchild、rchild和parent，分别指向结点的左孩子、右孩子和双亲（父结点）。如果某个孩子结点或父结点不存在，则相应属性的值为空（NIL）。根结点是树中唯一父指针为NIL的结点，而叶子结点的孩子结点指针也为NIL。 ...
c++实现二叉查找树示例
09-04
二叉查找树（Binary Search ...以上就是C++实现二叉查找树的基本原理和结构。通过这个示例，我们可以学习到如何使用C++的数据结构和算法来构建和操作一种重要的数据结构，这对于理解和处理复杂的数据问题非常有帮助。
二叉查找树C++实现
12-23
通过阅读和理解这些代码，你可以深入学习二叉查找树的工作原理，以及如何用C++有效地实现它们。此外，还可以尝试扩展这些功能，例如实现中序遍历、前序遍历和后序遍历，或者优化删除操作以减少树的不平衡性，如AVL树...
Java二叉搜索树基础原理与实现方法详解
08-19
* 二叉查找树本质上是一种二叉树，所以上章讲的二叉树的性质它都有。 二叉搜索树的思想： * 二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。 * 中序遍历二叉排序树可得到一个...
三元组、循环链表以及二叉查找树.zip_三元_三元组_二叉查找树_循环链表
09-21
总结来说，这个压缩包提供了一套关于三元组、循环链表和二叉查找树的实践示例，对于学习和理解这些数据结构的原理和使用非常有帮助。通过阅读和分析这些代码，开发者可以提升自己在数据结构和算法方面的技能，从而更...
二叉搜索树原理及操作
H48530的博客
04-09 582
二叉搜索树原理构建二叉搜索树查找插入删除 原理 二叉搜索树（Binary Search Tree BST） 又称为二叉排序树，它是一颗空树或者具有以下性质： 它的左子树不为空，则左子树上所有节点的值都小于根节点的值 它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也是二叉搜索树 简单来说： 每个结点， 节点左子树中所有的key值，都小于节点的key值； 节点右子树中所有的key值，都大于节点的key值 所以：二叉搜索树的中序遍历，一定有序 构建二叉搜索树 节点： publi
二叉搜索树原理及实现
dreamfantacy的博客
09-03 331
二叉搜索树原理及实现二叉搜索树性质查找插入(创建)删除前序遍历中序遍历后序遍历 二叉搜索树 性质 若任意节点的左子树不为空，则左子树的所有节点值均小于根节点的值； 若任意节点的右子树不为空，则右子树的所有节点值均大于跟节点的值； 任意节点的左、右子树也分别为二叉查找树； 没有键值相等的节点。 通常采用二叉链表作为二叉查找树的存储结构： struct BiTree { int ...
数据结构与算法--二叉查找树实现原理
0102的博客
12-15 337
二叉查找树 上一篇：数据结构与算法–二叉树
二叉搜索树的原理和实现
Meliorem的博客
11-20 893
什么是二叉搜索树二叉搜索树是一种特殊的二叉树，它是被广泛运用的存储查找结构------完全平衡二叉树（AVLtree） 和红黑树的基础（RBtree） 二叉搜索树的规则： 二叉搜索树可以是一棵空树 如果其节点的左子树不空 则其左子树上的所有节点的值小于根节点的值 如果其节点的右子树不空 则其右子树上的所有节点的值小于根节点的值 每个节点的左右子树都是二叉搜索树 为什么要设计出这种规则的二叉搜索树呢？
二叉搜索树的原理及其实现
画船听雨眠
10-26 660
二叉搜索树的原理及其实现 代码 #include <iostream> #include <vector> #include <algorithm> #include <queue> using namespace std; struct poi { int val; poi *l, *r; poi() {} poi(int ...
树结构——二叉查找树原理与实现
gjbss的博客
07-28 382
二叉查找树实现，查找二叉树中最小键，最大键，遍历方法：前序遍历，中序遍历，后序遍历；层序遍历；折纸问题
树结构(一) - 二叉树查找树的原理与实现
I_will_try的博客
12-20 591
原文：http://blog.csdn.net/leicool_518/article/details/42491273 一、二叉树查找树的原理 二叉查找树(Binary Search Tree)，它是特殊的二叉树：对于二叉树，假设x为二叉树中的任意一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y] = key[x]。那么，这
二叉排序树的基本原理和实现方法（Java）
qq_41291067的博客
10-27 1434
二叉排序树基本介绍： 二叉排序树（BST）: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 比如针对前面的数据 (7, 3, 10, 12, 5, 1, 9，2) ，对应的二叉排序树为： 算法分析： 二叉排序树创建和遍历： ...
AVL树笔记（一）:zig-zag,insert,find,predecessor,successor
Quack
11-16 2118
AVL树就是一棵平衡的二叉查找树。 其维护平衡的方式是：维护一个平衡因子h，即子树高度，如果左子树高度和右子树高度相差2，那么就旋转把它弄平衡。 旋转是怎么转的这就不细说了，每个PPT都写了。 这个二叉树明显不平衡，可以发现全部左偏，于是右旋。 右旋就是当前节点的左儿子 的 右儿子是当前节点。 如果当前节点有右儿子，怎么办？ 那么把这个右儿子拆下来然后装在当前节点的左儿子上。 如图
中序遍历二叉排序树：BinarySearchTree:Create a tree and InorderTree
woshipangxiaofeng的专栏
12-04 454
// BinaryTree.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include "iostream"using namespace std;typedef struct _node{ struct _node* lch; struct _node* rch; int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值