二叉查找树

最新推荐文章于 2024-10-01 22:51:02 发布
最新推荐文章于 2024-10-01 22:51:02 发布
阅读量540 收藏
点赞数
分类专栏： 数据结构 文章标签： null delete search tree 数据结构 insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alongela/article/details/8095989
版权

二叉查找树是一种特殊的二叉树，除了拥有普通二叉树的性质之后，这种数据结构最重要的特征是：对于任何一个结点，它的值都大于或等于它的左子树上所有结点的值，而小于它的右子树上所有结点的值。这种数据结构有较高的查找效率和插入效率，同时为了方便各种操作，还在每个结点中引入一个指针域，用于指向结点的父亲。

二叉查找树一般的操作包括以下几种：

1、查找是否存在某个结点，其值等于给定值

对于查找操作，只需要从根结点开始，对比给定值于当前结点的值的大小，若相等，则返回当前结点；若给定值小于当前结点的值，则往当前结点的左子树中查找；否则往当前结点的右子树中查找。

2、插入一个新结点

对于插入操作，需要先找到在哪个位置进行插入操作，因此类似于查找操作，先从上到下找到最后一个非空结点。然后判断新结点的值与该结点的值的大小关系，若新结点的值比较小或两者相等，则将新结点作为该结点的左孩子，否则作为右孩子。

3、删除某个结点

删除某个结点需要进行一些判断。首先是判断要删除的结点是不是根结点，其次是判断要删除的结点的孩子状况。

主要包括以下几种情况：

（1）根结点，无孩子：直接删除，将根结点置空即可

（2）根结点，有左孩子：将左孩子作为新的根结点，删除当前结点

（3）根结点，有右孩子：将右孩子作为新的根结点，删除当前结点

（4）根结点，有两个孩子：先获取左子树中值最大的结点，将它作为新的根结点，当前根结点的右子树作为新的根结点的右子树，删除当前根结点

（5）非根结点，无孩子：直接删除，将父亲结点的相应指针置空即可

（6）非根结点，有左孩子：将父亲结点的相应指针指向当前结点的左孩子，删除当前结点

（7）非根结点，有右孩子：将父亲结点的相应指针指向当前结点的右孩子，删除当前结点

（8）非根结点，有两个孩子：找到左子树中值最大的结点，将当前结点的值修改为该最大值，删除刚刚找到的左子树中值最大的结点，再修改相应的指针

4、遍历树中的所有结点（先序、中序、后序）

这个类似于二叉树的遍历，用递归即可。

5、获取以某个结点为根的树上的结点值最大和最小的结点

从当前结点一直往左走到尽头，即可获得最小值。同理，从当前结点一直往右走到尽头，即可获得最大值。

6、（非常用操作）获取在先序遍历中，某个结点的前缀和后缀


详细代码如下：

//BinarySearchTree.h

#ifndef _BINARY_SEARCH_TREE_
#define _BINARY_SEARCH_TREE_

#include <iostream>

class TreeNode
{
public:
	TreeNode* parent;	//结点的父亲
	TreeNode* lchild;	//结点的左孩子
	TreeNode* rchild;	//结点的右孩子
	int val;			//结点的值
	TreeNode(int _val);
	~TreeNode();
};

class BinarySearchTree
{
public:
	BinarySearchTree(TreeNode* _root = NULL);
	~BinarySearchTree();
	TreeNode* getRoot();	//返回根结点
	TreeNode* getMinimum(TreeNode* _root);	//返回值最大的结点
	TreeNode* getMaximum(TreeNode* _root);	//返回值最小的结点
	TreeNode* searchValue(int _val);		//查找值等于某个数的结点
	TreeNode* getSuccessor(TreeNode* _treeNode);	//返回中序遍历时，某个结点的后缀
	TreeNode* getPredecessor(TreeNode* _treeNode);	//返回中序遍历时，某个结点的前缀
	void insertNode(TreeNode* _treeNode);	//插入结点
	void deleteNode(TreeNode* _treeNode);	//删除结点
	void inOrderTraverse(TreeNode* root);	//中序遍历
	void preOrderTraverse(TreeNode* root);	//先序遍历
	void postOrderTraverse(TreeNode* root);	//后序遍历
protected:
private:
	TreeNode* root;	//二叉树的根
	void deleteTree(TreeNode* _root);	//删除二叉树中的结点，用于清理空间
};

#endif

//BinarySearchTree.cpp

#include "BinarySearchTree.h"
using namespace std;

TreeNode::TreeNode(int _val): parent(NULL), lchild(NULL), rchild(NULL), val(_val)
{

}

TreeNode::~TreeNode()
{

}

BinarySearchTree::BinarySearchTree(TreeNode* _root): root(_root)
{

}

BinarySearchTree::~BinarySearchTree()
{
	deleteTree(root);
}

TreeNode* BinarySearchTree::getRoot()
{
	return root;
}

TreeNode* BinarySearchTree::getMinimum(TreeNode* _root)
{
	if (_root == NULL) return NULL;
	TreeNode* temp = _root;
	while (temp->lchild)
	{
		temp = temp->lchild;
	}
	return temp;
}

TreeNode* BinarySearchTree::getMaximum(TreeNode* _root)
{
	if (_root == NULL) return NULL;
	TreeNode* temp = _root;
	while (temp->rchild)
	{
		temp = temp->rchild;
	}
	return temp;
}

TreeNode* BinarySearchTree::searchValue(int _val)
{
	TreeNode* temp = root;
	while (temp != NULL && temp->val != _val)
	{
		if (temp->val > _val) temp = temp->lchild;
		else temp = temp->rchild;
	}
	return temp;
}

TreeNode* BinarySearchTree::getSuccessor(TreeNode* _treeNode)
{
	TreeNode* temp = _treeNode;
	if (temp->rchild) return getMinimum(temp->rchild);
	TreeNode* p = temp->parent;
	while (p && p->rchild == temp)
	{
		temp = p;
		p = p->parent;
	}
	return p;
}

TreeNode* BinarySearchTree::getPredecessor(TreeNode* _treeNode)
{
	TreeNode* temp = _treeNode;
	if (temp->lchild) return getMaximum(temp->lchild);
	TreeNode* p = temp->parent;
	while (p && p->lchild == temp)
	{
		temp = p;
		p = p->parent;
	}
	return p;
}

void BinarySearchTree::insertNode(TreeNode* _treeNode)
{
	TreeNode* p = root;
	TreeNode* temp = NULL;
	while (p)
	{
		temp = p;
		if (p->val >= _treeNode->val) p = p->lchild;
		else p = p->rchild;
	}
	if (!temp) root = _treeNode;
	else if (temp->val >= _treeNode->val)
	{
		temp->lchild = _treeNode;
		_treeNode->parent = temp;
	}
	else
	{
		temp->rchild = _treeNode;
		_treeNode->parent = temp;
	}
}

void BinarySearchTree::deleteNode(TreeNode* _treeNode)
{
	if (_treeNode->lchild && _treeNode->rchild)
	{
		TreeNode* maxNode = getMaximum(_treeNode->lchild);
		if (maxNode->parent == _treeNode)
		{
			maxNode->rchild = _treeNode->rchild;
			maxNode->parent = NULL;
			delete _treeNode;
			root = maxNode;
		}
		else
		{
			maxNode->parent->rchild = maxNode->lchild;
			if (maxNode->lchild) maxNode->lchild->parent = maxNode->parent;
			_treeNode->val = maxNode->val;
			delete maxNode;
		}
	}
	else if (_treeNode->lchild)
	{
		if (_treeNode->parent == NULL)
		{
			root = _treeNode->lchild;
			root->parent = NULL;
			delete _treeNode;
		}
		else
		{
			TreeNode* p = _treeNode->parent;
			if (p->lchild == _treeNode)	p->lchild = _treeNode->lchild;
			else p->rchild = _treeNode->lchild;
			_treeNode->lchild->parent = p;
			delete _treeNode;
		}
	}
	else if (_treeNode->rchild)
	{
		if (_treeNode->parent == NULL)
		{
			root = _treeNode->rchild;
			root->parent = NULL;
			delete _treeNode;
		}
		else
		{
			TreeNode* p = _treeNode->parent;
			if (p->lchild == _treeNode) p->lchild = _treeNode->rchild;
			else p->rchild = _treeNode->rchild;
			_treeNode->rchild->parent = p;
			delete _treeNode;
		}
	}
	else
	{
		if (_treeNode->parent == NULL) 
		{
			delete _treeNode;
			root = NULL;
		}
		else
		{
			TreeNode* p = _treeNode->parent;
			if (p->lchild == _treeNode) p->lchild = NULL;
			else p->rchild = NULL;
			delete _treeNode;
		}
	}	
}

void BinarySearchTree::deleteTree(TreeNode* _root)
{ 
	if (!_root) return;
	if (_root->lchild) deleteTree(_root->lchild);
	if (_root->rchild) deleteTree(_root->rchild);
	delete _root;
}

void BinarySearchTree::inOrderTraverse(TreeNode* _root)
{
	if (!_root) return;
	if (_root->lchild) inOrderTraverse(_root->lchild);
	cout << _root->val << endl;
	if (_root->rchild) inOrderTraverse(_root->rchild);
}

void BinarySearchTree::preOrderTraverse(TreeNode* _root)
{
	if (!_root) return;
	cout << _root->val << endl;
	if (_root->lchild) preOrderTraverse(_root->lchild);
	if (_root->rchild) preOrderTraverse(_root->rchild);	
}

void BinarySearchTree::postOrderTraverse(TreeNode* _root)
{
	if (!_root) return;
	if (_root->lchild) postOrderTraverse(_root->lchild);
	if (_root->rchild) postOrderTraverse(_root->rchild);
	cout << _root->val << endl;
}

//main.cpp

#include "BinarySearchTree.h"
#include <string>
using namespace std;

int main()
{
	string str;
	int val;
	TreeNode* node;
	BinarySearchTree bst;
	while (cin >> str)
	{
		if (str == "SEARCH" || str == "search")
		{
			cin >> val;
			node = bst.searchValue(val);
			if (node) cout << "find " << val << " successfully!" << endl;
			else cout << "can't find " << val << endl;
		}
		else if (str == "INSERT" || str == "insert")
		{
			cin >> val;
			bst.insertNode(new TreeNode(val));
		}
		else if (str == "DELETE" || str == "delete")
		{
			cin >> val;
			node = bst.searchValue(val);
			if (node) bst.deleteNode(node);
		}
		else if (str == "MAX" || str == "max")
		{
			node = bst.getRoot();
			if (node) cout << bst.getMaximum(node)->val << endl;
			else cout << "the tree is empty" << endl;
		}
		else if (str == "MIN" || str == "min")
		{
			node = bst.getRoot();
			if (node) cout << bst.getMinimum(node)->val << endl;
			else cout << "the tree is empty" << endl;
		}
		else if (str == "INORDER" || str == "inorder")
		{
			node = bst.getRoot();
			bst.inOrderTraverse(node);
		}
		else if (str == "PREORDER" || str == "preorder")
		{
			node = bst.getRoot();
			bst.preOrderTraverse(node);
		}
		else if (str == "POSTORDER" ||str == "postorder")
		{
			node = bst.getRoot();
			bst.postOrderTraverse(node);
		}
		else if (str == "SUCCESSOR" || str == "successor")
		{
			cin >> val;
			node = bst.searchValue(val);
			if (!node) cout << "can't find " << val << endl;
			else
			{
				node = bst.getSuccessor(node);
				if (!node) cout << "no successor for " << val << endl;
				else cout << node->val << endl;
			}
		}
		else if (str == "PREDECESSOR" || str == "predecessor")
		{
			cin >> val;
			node = bst.searchValue(val);
			if (!node) cout << "can't find " << val << endl;
			else
			{
				node = bst.getPredecessor(node);
				if (!node) cout << "no predecessor for " << val << endl;
				else cout << node->val << endl;
			}
		}
		else break;
	}
	return 0;
}


Onlyan
关注
专栏目录
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉查找树python二叉查找树源码
11-22
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构。它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉查找树中，对于...
二叉查找树详细介绍.docx
06-27
二叉查找树（BST，Binary Search Tree）是一种特殊类型的二叉树，它的每个节点都遵循以下规则： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点的值都大于该节点的值。 3. 左右子树也...
等价二叉查找树
01-07
练习：等价二叉查找树 实现 Walk 函数。 测试 Walk 函数。 函数 tree.New(k) 用于构造一个随机结构的已排序二叉查找树，它保存了值 k, 2k, 3k, …, 10k。 创建一个新的信道 ch 并且对其进行步进： go Walk(tree.New...
单调栈
热门推荐
Shuyu Fang
11-26 1万+
单调栈与单调队列很相似。首先栈是后进先出的，单调性指的是严格的递增或者递减。 单调栈有以下两个性质： 1、若是单调递增栈，则从栈顶到栈底的元素是严格递增的。若是单调递减栈，则从栈顶到栈底的元素是严格递减的。 2、越靠近栈顶的元素越后进栈。 单调栈与单调队列不同的地方在于栈只能在栈顶操作，因此一般在应用单调栈的地方不限定它的大小，否则会造成元素无法进栈。 元素进栈过程：对于单调递增栈，若当
单调队列
Shuyu Fang
11-26 1049
队列是一种先进先出的数据结构，单调指的是数学中的单调性，包括严格的递增或者递减。 单调队列指的就是严格符合单调性的队列，它有两个性质： 1、对于单调递增队列，从队头到队尾的元素在某种比较标准下是严格递增的，比如q(1, 2, 3, 4, 5)。对于单调递减队列，从队头到队尾的元素在某种比较标准下是严格递减的，比如q(5, 4, 3, 2, 1)。 2、排在前面的元素必定比排在后面的元素先进队
树状数组
Shuyu Fang
10-27 709
树状数组是一种非常巧妙的数据结构。对于一个普通数组，可以构造出一个对应的树状数组。普通数组中的元素存放的只是本身的信息，但树状数组中的元素存放的却是多个原数组的信息。 对于一个非负整数x，我们可以将它表示为二进制，设它的二进制形式中，结尾的0的个数为k。 对于树状数组，它的x位置上的元素表示的是原数组从x位置开始，往后数2^k个元素的信息（一般是它们的和，也可以是最大值或最小值）。 比如：
字典树(Trie)
Shuyu Fang
11-10 651
字典树是一种用于字符串处理的高级数据结构。 字典树的形态不是固定的，它是根据需要处理的不同字符的数量来决定的。对于某种场合，有n种不同的字符，则对应的字典树就是n叉树。举个例子，假设需要处理的字符串只有小写字母组成，则一共有26种字符，此时构造出来的字典树就是一棵26叉树，即每个结点有26个子结点。 边：字典树上的每条边代表一个字符。 结点：字典树上的每个结点中包含了它的所有孩子的指针，以及
优先队列
Shuyu Fang
12-04 623
优先队列是一种特殊的队列，它同样具备入队与出队两种基本操作，但每次出队的元素都是队列中最大（最小）的元素，这里的最大与最小相当于优先级，因此这种队列叫优先队列。 优先队列的实现方式不唯一，其中有一种是用堆实现的。对于堆实现的优先队列，它的入队操作相当于在堆的最后一个元素之后加入一个新元素，然后逐步往上浮动直到不需浮动为止；而出队操作则是保存堆顶的元素，然后把堆的最后一个元素放到第一个元素的位置上
线段树
Shuyu Fang
10-27 539
线段树是一种由二叉树扩展而来的数据结构。 线段树中的每个结点都包含一个区间，每一个结点要么包含两个儿子结点，要么是叶结点。 包含两个儿子的结点，它的左儿子表示它的左半部分区间，右儿子表示它的右半部分区间。 叶子结点的区间长度为1，即起点和终点重合。 线段树的构造： 给定一个区间[beg, end]，以此构造出一个结点。若beg等于end，说明该结点是叶子结点，构造结束。否则求出该
并查集
Shuyu Fang
11-21 383
并查集是一种用于不相交集合上的操作的高级数据结构。 对于不相交集合，一般的操作包括两种：查询某个结点所属集合的代表元素、合并两个集合。 针对这两种操作，我们可以设计这样一种数据结构： 用编号0－n表示所有结点，用一个数组 parent[ ] 存储他们所属的集合的代表元素的编号。 初始化时，每个元素单独构成一个集合，因此 parent[i] = i。 当执行合并操作的时候，比如说把
【高阶数据结构】平衡二叉树(AVL)的删除和调整
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
09-26 971
平衡二叉树节点的删除方法详细讲解；平衡二叉树的删除代码实现(C++);
数据结构-3.8.栈在括号匹配中的应用
ADCvbV的博客
10-01 247
把左括号依次压入栈中，越往后压入栈的左括号越先被匹配即被弹出栈->先进后出，后进先出当遇到左括号就压入栈中，当遇到右括号就把栈顶的左括号弹出，检查该右括号和左括号是否匹配当遇到一个不匹配的就停止压入栈，因为之后的括号必定都不匹配。其中Y代表Yes，N代表No1.对于bracketCheck函数，形参str[]是传入的一个字符串，length是该字符串的长度；字符topElem代表栈顶元素；return StackEmpty(S)如果是return false说明栈不为空，则左括号单身；创建栈顶元素topEl
数据结构-3.10.队列的应用
最新发布
ADCvbV的博客
10-01 192
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1132
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1177
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
哈希表(HashMap、HashSet)
wuweixiaoyue的博客
09-28 1007
是个存储结构：可以让我们一次从表中直接拿到想要的元素，时间复杂度为O(1)为什么能实现O(1)：通过哈希(散列)方法，使元素的存储位置和它的关键码之间建立一一映射的关系如果想要存取元素，都是利用哈希(散列)方法 + 关键码，从而计算出index位置，然后进行操作（怎么放的就怎么给它取出来哈希函数示例：此时写着容量是1000，但实际上是2次幂数，容量为1024。
Java二叉查找树的实现代码详解
Java二叉查找树的实现代码 Java二叉查找树是一种常用的数据结构，它能够高效地存储和检索数据。在本文中，我们将详细地介绍Java二叉查找树的实现代码，并对其进行详细的解释。 一、Java二叉查找树的定义 Java二叉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值