【数据结构】中的二叉搜索树-BinarySearchTree

最新推荐文章于 2022-01-31 15:39:41 发布
最新推荐文章于 2022-01-31 15:39:41 发布
阅读量403 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LX18792732127/article/details/68944561
版权

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

二叉搜索树的性质：
1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。
2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。
3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。
4. 左右子树都是二叉搜索树。

接下来实现一下二叉搜索树：

二叉搜索树的插入：

非递归实现：

bool Insert(const T& k)
	{
		if (_root == NULL)
		{
			return true;
		}
		Node* cur = _root;
		Node* parent = cur;

		while (cur)
		{
			parent = cur;
			if (cur->_key < k)
			{
				cur = cur->_right;
			}
			else if (cur->_key>k)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		if (parent->_key > k)
		{
			parent->_left = new Node(k);
		}
		else if (parent->_key < k)
		{
			parent->_right = new Node(K);
		}
		return true;
	}

递归实现：

bool InsertR(const T& k)
	{
		return _InsertR(_root, k);
	}
bool _InsertR(Node* root, const T& k)
	{
		if (root == NULL)
		{
			root = new Node(k);
			return true;
		}
		if (root->_key > k)
		{
			return _InsertR(root->_left, k);
		}
		else if (root->_key < k)
		{
			return _InsertR(root->_right, k);
		}
		else
		{
			return false;
		}
	}

二叉搜索树的查找：

非递归实现：

Node* Find(const T& k)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > k)
			{
				cur = cur->_left;
			}

			else if (cur->_key < k)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return NULL;
	}

递归实现：

Node* FindR(const T& k)
	{
		return _FindR(_root, k);
	}
void _FindR(Node* root, const T& k)
	{
		if (root == NULL)
		{
			return NULL;
		}
		if (root->_key < k)
		{
			return _FindR(root->_right, k);
		}
		else if (root->_key > k)
		{
			return _FindR(root->_left, k);
		}
		else
		{
			return root;
		}
	}

二叉搜索树的删除：

非递归实现：

bool Remove(const T& k)
	{
		Node* cur = _root;
		Node* parent = NULL;
		Node* del = cur;


		while (cur)
		{
			if (cur->_key < k)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key>k)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				break;
			}
		}
		if (cur == NULL)
		{
			return false;
		}
		if (cur->_left == NULL)
		{
			del = cur;
			if (cur == _root)
			{
				_root = cur->_right;
			}
			else if (cur == parent->_left)
			{
				parent->_left = cur->_right;
			}
			else
			{
				parent->_right = cur->_right;
			}
		}

		else if (cur->_right == NULL)
		{
			del = cur;
			if (cur == parent->_left)
			{
				_root = cur->_right;
			}
			else if (cur = parent->_right)
			{
				parent->_key = cur->_left;
			}
			else
			{
				parent->_right = cur->_right;
			}
		}

		else
		{
			Node* subleft = NULL;

			subleft = cur->_right;
			parent = cur;
			while (subleft->_left)
			{
				parent = cur;
				subleft = subleft->_left;
			}
			cur->_key = subleft->_key;

			if (parent->_left == subleft)
			{
				parent->_left = subleft->_right;
			}
			else if (parent->_right == subleft)
			{
				parent->_right = subleft->_right;
			}
			del = subleft;
		}
		delete del;
		del = NULL;
		return true;
	}

递归实现：

bool RemoveR(const T& k)
	{
		return _RemoveR(_root, k);
	}
bool _RemoveR(Node* root, const T& k)
	{
		if (root == NULL)
		{
			return false;
		}
		Node* del = NULL;
		if (root->_key < k)
		{
			return _RemoveR(root->_right, k);
		}
		else if (root->_key>k)
		{
			return _RemoveR(root->_right, k);
		}
		else
		{
			if (root->_left == NULL)
			{
				del = root;
				root = root->_right;
			}
			else if (root->_right == NULL)
			{
				del = root;
				root = root->_left;
			}
			else
			{
				Node* subleft = root->_right;
				Node* parent = root;

				while (subleft->_left)
				{
					subleft = subleft->_left;
					parent = subleft;
				}
				if (parent->_left == subleft)
				{
					parent->_left = subleft->_right;
				}
				else
				{
					parent->_right = subleft->_right;
				}
				
			}
			delete del;
			del = NULL;
		}
	}      

下面是完整的代码：

#include<iostream>
using namespace std;

#include<assert.h>

template<class T>
struct SearchBinaryTreeNode
{
	SearchBinaryTreeNode<T>* _left;
	SearchBinaryTreeNode<T>* _right;

	T _key;

	SearchBinaryTreeNode(const T& k)
		:_left(NULL)
		,_right(NULL)
		,_key(k)
	{}
};

template<class T>
class SearchBinaryTree
{
	typedef SearchBinaryTreeNode<T> Node;

public:
	SearchBinaryTree()
		:_root(NULL)
	{
	}

	~SearchBinaryTree()
	{
		_Destory(_root);
		_root = NULL;
	}

	//插入任意数字
	bool Insert(const T& k)
	{
		if (_root == NULL)
		{
			return true;
		}
		Node* cur = _root;
		Node* parent = cur;

		while (cur)
		{
			parent = cur;
			if (cur->_key < k)
			{
				cur = cur->_right;
			}
			else if (cur->_key>k)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		if (parent->_key > k)
		{
			parent->_left = new Node(k);
		}
		else if (parent->_key < k)
		{
			parent->_right = new Node(K);
		}
		return true;
	}

	//查找任意数字
	Node* Find(const T& k)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > k)
			{
				cur = cur->_left;
			}

			else if (cur->_key < k)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return NULL;
	}



	//删除一个节点
	bool Remove(const T& k)
	{
		Node* cur = _root;
		Node* parent = NULL;
		Node* del = cur;


		while (cur)
		{
			if (cur->_key < k)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key>k)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				break;
			}
		}
		if (cur == NULL)
		{
			return false;
		}
		if (cur->_left == NULL)
		{
			del = cur;
			if (cur == _root)
			{
				_root = cur->_right;
			}
			else if (cur == parent->_left)
			{
				parent->_left = cur->_right;
			}
			else
			{
				parent->_right = cur->_right;
			}
		}

		else if (cur->_right == NULL)
		{
			del = cur;
			if (cur == parent->_left)
			{
				_root = cur->_right;
			}
			else if (cur = parent->_right)
			{
				parent->_key = cur->_left;
			}
			else
			{
				parent->_right = cur->_right;
			}
		}

		else
		{
			Node* subleft = NULL;

			subleft = cur->_right;
			parent = cur;
			while (subleft->_left)
			{
				parent = cur;
				subleft = subleft->_left;
			}
			cur->_key = subleft->_key;

			if (parent->_left == subleft)
			{
				parent->_left = subleft->_right;
			}
			else if (parent->_right == subleft)
			{
				parent->_right = subleft->_right;
			}
			del = subleft;
		}
		delete del;
		del = NULL;
		return true;
	}

	//查找一个数字
	Node* FindR(const T& k)
	{
		return _FindR(_root, k);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	//插入一个数字
	bool InsertR(const T& k)
	{
		return _InsertR(_root, k);
	}
	
	//删除一个数字
	bool RemoveR(const T& k)
	{
		return _RemoveR(_root, k);
	}

protected:
	//销毁
	void _Destory(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		_Destory(root->_left);
		_Destory(root->_right);
	}

	//查找
	void _FindR(Node* root, const T& k)
	{
		if (root == NULL)
		{
			return NULL;
		}
		if (root->_key < k)
		{
			return _FindR(root->_right, k);
		}
		else if (root->_key > k)
		{
			return _FindR(root->_left, k);
		}
		else
		{
			return root;
		}
	}

	//递归法插入一个数据
	bool _InsertR(Node* root, const T& k)
	{
		if (root == NULL)
		{
			root = new Node(k);
			return true;
		}
		if (root->_key > k)
		{
			return _InsertR(root->_left, k);
		}
		else if (root->_key < k)
		{
			return _InsertR(root->_right, k);
		}
		else
		{
			return false;
		}
	}

	//删除一个数字
	bool _RemoveR(Node* root, const T& k)
	{
		if (root == NULL)
		{
			return false;
		}
		Node* del = NULL;
		if (root->_key < k)
		{
			return _RemoveR(root->_right, k);
		}
		else if (root->_key>k)
		{
			return _RemoveR(root->_right, k);
		}
		else
		{
			if (root->_left == NULL)
			{
				del = root;
				root = root->_right;
			}
			else if (root->_right == NULL)
			{
				del = root;
				root = root->_left;
			}
			else
			{
				Node* subleft = root->_right;
				Node* parent = root;

				while (subleft->_left)
				{
					subleft = subleft->_left;
					parent = subleft;
				}
				if (parent->_left == subleft)
				{
					parent->_left = subleft->_right;
				}
				else
				{
					parent->_right = subleft->_right;
				}
				
			}
			delete del;
			del = NULL;
		}
	}

	void _InOrder(Node* root)
	{
		if (root == NULL)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

protected:
	Node* _root;
};


void Test()
{
	int arr[] = { 2, 4, 6, 8, 3, 5, 7, 9, 0 };
	SearchBinaryTree<int> s;

	for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		s.InsertR(arr[i]);
	}
	s.InOrder();
	s.RemoveR(4);
	s.RemoveR(8);
	s.RemoveR(10);
	s.RemoveR(11);
	s.RemoveR(15);

	s.InOrder();

	s.RemoveR(4);
	s.RemoveR(5);
	s.RemoveR(10);
	s.RemoveR(11);
	s.RemoveR(15);


}

int main()
{
	Test();
	system("pause");
	return 0;
}










筱肖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
binary_search_tree
瑶子的博客
09-27 281
reference:https://github.com/EchoLLLiu/DataStructure/blob/master/ch04tree/BinarySearchTree.py #-*- coding:utf-8 -*- # @Author:zhangy # @Time:2019-09-27 16:16 #reference:https://github.com/EchoLLLiu/Da...
二叉查找树（ binary search tree）
11-04 107
树中的每一个节点包含特定人员的数据。人名是查找关键字，是可在图中看到的唯一的数据项。下面的c++语句描述了树节点中的数据： #include using namespace std; typedef string keyType; class KeyItem { public: KeyItem(); KeyItem(const KeyType &keyValue)
编程练习——二叉查找树（BinarySearchTree）
帐前卒 专栏
08-19 1072
 BinarySearchTree和BinaryTree其实可以使用相同的构造和析构函数，所以继承吧。懒得再写一遍templateclass BinarySearchTree:public BinaryTree{public: BinarySearchTree(T& data):BinaryTree(data) {   } ~BinarySearchTree() {   } void in
二叉搜索树（BinarySearchTree）相关操作（C++）
mirrorboat的博客
01-31 756
#include<stdio.h> #include<stdlib.h> #include<queue> #include<iostream> using namespace std; typedef struct node { int val; node* left; node* right; }node; node* Create(int val) { node* temp=NULL; temp=(node*)malloc(sizeof(no.
详解二叉搜索树(BinarySearchTree)
鱼儿往上游的博客
06-24 873
I 二叉搜索树特点 每个结点有唯一的值，且每个结点的值均不相同； 若它的左子树不为空，则它的左子树的所有结点均小于根节点的值； 若它的右子树不为空，则它的右子树的所有结点均大于根结点的值； 它的左右子树均为二叉搜索树。 II 二叉搜索树的操作 二叉查找树由节点组成，所以需要一个 Node 类 public class Node { public int Data; public Node left; public Node right; public void.
js代码-12.3 二叉搜索树-删除节点
07-16
在JavaScript编程中，二叉搜索树（Binary Search Tree，BST）是一种特殊的数据结构，它具有以下特性：每个节点的左子树只包含小于该节点的元素，右子树只包含大于该节点的元素。这样的性质使得二叉搜索树在查找、...
javascript数据结构之二叉搜索树实现方法
11-24
二叉搜索树是一种特殊的数据结构，它在计算机科学中用于高效地存储和检索有序数据。在JavaScript中，我们可以创建一个二叉搜索树类来实现这些功能。以下是对标题和描述中提到的知识点的详细说明： 1. **二叉搜索树...
js代码-12.2 二叉搜索树-插入新节点
07-16
在JavaScript编程中，二叉搜索树（Binary Search Tree，BST）是一种特殊的数据结构，它具有以下特性：每个节点包含一个键（key）、一个值、一个指向左子节点的引用和一个指向右子节点的引用。在二叉搜索树中，对于...
js代码-12.1 二叉搜索树-查找指定节点
07-16
在JavaScript编程中，二叉搜索树（Binary Search Tree, BST）是一种非常重要的数据结构，它具有自平衡特性，使得在树中的查找、插入和删除操作的平均时间复杂度为O(log n)。在这个主题"js代码-12.1 二叉搜索树-查找...
二叉搜索树实例练习
09-05
总结来说，二叉搜索树是一种高效的数据结构，特别适合于需要快速查找、插入和删除操作的场景。通过掌握其基本性质和操作，我们可以解决如判断序列是否对应相同二叉搜索树等实际问题。在编程实践中，理解二叉搜索树的...
数据结构——二叉搜索树(BinarySearchTree)的实现
来自星星的の松子的博客
01-31 669
二叉搜索树是二叉树的一种扩展。树中的元素可以看作是有序的。由于特殊的结构，它非常适合进行二分查找操作，且查找的平均时间复杂度为O(logN)。不过其也可能退化为一个链表，此时查找的最坏时间复杂度变为O(N)。
二叉搜索树
魔仙佩奇
03-21 114
二叉搜索树 **插入 template<class T> void InsertNode(BinaryTreeNode<T> *root , BinaryTreeNode<T> *newpointer) { BinaryTreeNode<T> *pointer = NULL; ...
C++模板定义和实现分离导致的编译错误
GVFDBDF的专栏
07-21 1588
今天在实现一个二叉树的时候，用到了模板，没在意，和平时一样写了两个文件：BinaryTree.h，BinaryTree.cpp。思路和平时一样，h文件中定义了模板类，然后在cpp文件中实现了一些功能函数。然后在test.cpp中测试，遇到了一些问题、问题出现如下： 使用g++直接编译的时候提示，基本上都是undefined reference to错误： test_binarytree.cpp:(.
二叉树（Binary Tree）详解
To_be_thinking的博客
11-30 6082
二叉树本身就是递归定义的（wikipedia）： To actually define a binary tree in general, we must allow for the possibility that only one of the children may be empty. An artifact, which in some textbooks is called an e...
数据结构实验——二叉树的基本操作与算法设计（先根、中根、后根遍历，查找关键字）
weixin_45823684的博客
01-13 1434
① 先根次序遍历查找首个关键字为key BinaryNode<T> search(T key) ② 返回key结点所在的层次 int level(T key) 三、实验方法与步骤（需求分析、算法设计思路、流程图等） 实验一： 先根次序遍历查找首个关键字为key 分析： 首先要构造空二叉树，先根次序遍历二叉树。返回先根次序遍历二叉树所有结点的描述字符串，包含空子树标记。在以p为根的...
二叉查找树（binary search tree）的实现算法分析
wangxiaohigh
11-17 295
此文为《data abstraction and problem solving with c++》的读书笔记。这里有个图书管理系统模拟的应用实例 树中的每一个节点包含特定人员的数据。人名是查找关键字，是可在图中看到的唯一的数据项。下面的c++语句描述了树节点中的数据： #include&lt;string&gt; using namespace std; typedef string...
数据结构与算法（八）二分搜索树(Binary Search Tree)
Chiclaim
06-06 4582
本文主要包括以下内容： 二分搜索树的基本概念 二分搜索树的基本操作 插入 删除 查询 实现二分搜索树 二分搜索树的不足 二分搜索树的基本概念 二分搜索树(Binary Search Tree)满足一下几个条件： 若它的左子树不为空，左子树上所有节点的值都小于它的根节点 若它的右子树不为空，右子树上所有的节点的值都大于它的根节点 它的左、右子树也都是二分搜索树 如果插入的元素在二...
二叉树
adityasaber的博客
10-23 3267
暂时先写了这八个方法 二叉树增加成员方法 BinaryTree二叉树类增加以下成员方法，public权限。 （1）成员方法，递归算法 6-1 BinaryTree(T prelist[], T inlist[]) //以先根和中根序列构造二叉树 6-2 BinaryTree create(T inlist[], T postlist[]) ...
Binary Search Tree（二叉查找树）
热门推荐
kuma的博客
03-12 1万+
Binary Search Tree 也被成为 ordered binary tree（有序二叉树）或 sorted binary tree（排序二叉树）,有如下性质： 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 任意节点的左、右子树也分别为二叉查找树； 没有键值相等的节点。 和数组，链表的比较 数...
二叉查找树：高效动态数据操作的选择
"二叉查找树是数据结构中一种特殊类型的二叉树，主要用于快速查找、插入和删除操作。在二叉查找树中，每个节点的左子树包含所有小于该节点值的节点，而右子树包含所有大于该节点值的节点。这种结构使得搜索、插入和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值