二叉搜索树的实现

最新推荐文章于 2024-03-25 18:55:55 发布
最新推荐文章于 2024-03-25 18:55:55 发布
阅读量404 收藏
点赞数 1
分类专栏： 数据结构 c++&数据结构&linux 文章标签： 搜索二叉树 搜索 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33417547/article/details/52901543
版权
首先我们先来看看二叉搜索树的性质：
1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。
2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。
3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。

4. 左右子树都是二叉搜索树。

首先来看看二叉搜索树的插入：


1：首先判断树是否为空，为空就new新节点，放入key。

2：从根开始遍历，找要插入的数是否已经存在，如果存在就返回false。

3：如果不存在相同节点，则new新的节点进行插入。

代码如下：

bool Insert(const K& key)
	{
		if (_root==NULL)
		{
			_root=new Node(key);
			return true;
		}
		Node* cur=_root;
		Node* parent=NULL;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent=cur;
				cur=cur->_right;
			}
			else if (cur->_key > key)
			{
				parent=cur;
				cur=cur->_left;
			}
			else
				return false;
		}
          //不存在相同的key
		if(parent->_key < key)
		{
			parent->_right=new Node(key);
			return true;
		}
		else if(parent->_key > key)
		{
			parent->_left=new Node(key);
			return true;
		}
		else
			return false;

	}
下面是递归的实现方法： 

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

下来是搜索二叉树的查找：

给一个指针变量cur存放-root，让cur循环，判断cur的-key和你要找的key是否相等，如果相等就返回true，否侧返回false。

代码如下：

bool Find(const K& key)
	{
		Node *cur=_root;
		while (cur)
		{
			if(cur->_key < key)
				cur=cur->_right;
			else if(cur->_key > key)
				cur=cur->_left;
			else
				return true;
		}
		return false;
	}

下面的查找的递归实现： 

bool FindR(Node *& root , const K& key)
{
	if (root == NULL)
	{
		return false;
	}
	if (root->_key < key)
	{
		return FindR(root->_right,key)
	}
	else if (root->_key > key)
	{
		return FindR(root->_left,key)
	}
	else
		return true;
}

最后是二叉搜索树的删除：

首先我们要考虑以下这些情况：

  • 没有这个节点
  • 删除根节点
  • 删除左子树为空的节点
  • 删除右子树为空的节点
  • 删除左右子书都不为空的节点
如果没有这个节点就不删了，直接return；
删除的是左子树为空或者右子树为空的时候注意与root的关系，在进行删除；
如果左右子树都不为空，就需要运用交换删除的方法，就是将要删除的结点与他的左子树最大节点或者右子树最小节点交换，删除即可。
代码如下： 

<strong><span style="font-size:18px;">bool Remove(const K& key)
	{
		Node *cur = _root;
		Node *parent = NULL;
		Node *del = NULL;
		while (cur&&cur->_key!=key)
		{
			if (cur->_key < key)
			{

				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key>key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				break;
			}
		}
		if (cur == NULL)
		{
			return false;   
		}
		if (cur->_left == NULL)
		{

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

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

		}
		else
		{
			Node *minright = cur->_right;
			while (minright->_left)
			{
				parent = minright;
				minright = minright->_left;
			}
			del = minright;
			cur->_key = minright->_key;


			if (parent->_left = minright)
				parent->_left = minright->_right;
			else
				parent->_right = minright->_right;
		}
		delete del;
		del = NULL;
		return true;
	}
</span></strong>

下面是递归实现： 

bool _RemoveR(Node *&root , const K& key)
	{
		if (root ==NULL)
		{
			return false;
		}
		if (root->_key < key)
		{
			return _RemoveR(root->_right,key);
		}
		else if (root->_key > key)
		{
			return _RemoveR(root->_left,key);
		}
		else
		{
			Node* del=root;
			if (root->_left == NULL)
			{
				root = root->_right;
			}
			else if (root->_right == NULL)
			{
				root = root->_left;
			}
			else
			{
				Node* parent = root;
				Node * minright = root->_right;
				while (minright->_left)
				{
					parent = minright;
					minright = minright->_left;
				}
				root->_key = minright->_key;
//
				if (parent->_right == minright)
					parent->_right = minright->_right;
				else
					parent->_left = minright->_right;
				del = minright;
			}
			delete del;
			return true;
		}
		return false;
	}

好，到这里基本的函数实现就完成了。下面是源代码： 

#include <iostream>
#pragma once;
using namespace std;

template <class K>
struct SearchBinaryTreeNode
{
	K _key;   //关键字
	//V _value;
	SearchBinaryTreeNode *_left;
	SearchBinaryTreeNode *_right;
	SearchBinaryTreeNode(const K& key)
		:_key(key)
		,_left(NULL)
		,_right(NULL)
	{}
};

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

public:
	SearchBinaryTree()
	{
		_root=NULL;
	}

	SearchBinaryTree(const SearchBinaryTree<K>& sbt)
	{
		_root=_Copy();
	}
	~SearchBinaryTree()
	{
		_Destroy(_root);
	}
	SearchBinaryTree<K>& operator=(const SearchBinaryTree<K> sbt)
	{
		if (this != &sbt)    //防止自赋值
		{
			SearchBinaryTree<K> tmp(sbt);
			std::swap(_root,tmp._root);
		}
		return *this;
	}

public:

	bool RemoveR(const K& key)
	{
		return _RemoveR(_root,key);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout<<endl;
	}

	Node *_Copy(Node *root)
	{
		Node *cur=root;
		Node *proot=NULL;//proot是拷贝的新树的根结点
		if(cur)
		{
			proot=new Node(cur->_key);
			proot->_left=_Copy(cur->_left);
			proot->_right=_Copy(cur->_right);
		}
		return proot;
	}


	

	void _Destroy(Node *root)
	{
		if(root == NULL)
			return ;
		Node *cur=root;
		if(cur)
		{
			_Destroy(cur->_left);
			_Destroy(cur->_right);
			delete cur;
			cur=NULL;
		}
	}


	bool Insert(const K& key)
	{
		if (_root==NULL)
		{
			_root=new Node(key);
			return true;
		}
		Node* cur=_root;
		Node* parent=NULL;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent=cur;
				cur=cur->_right;
			}
			else if (cur->_key > key)
			{
				parent=cur;
				cur=cur->_left;
			}
			else
				return false;
		}
          //不存在相同的key
		if(parent->_key < key)
		{
			parent->_right=new Node(key);
			return true;
		}
		else if(parent->_key > key)
		{
			parent->_left=new Node(key);
			return true;
		}
		else
			return false;

	}

	bool Find(const K& key)
	{
		Node *cur=_root;
		while (cur)
		{
			if(cur->_key < key)
				cur=cur->_right;
			else if(cur->_key > key)
				cur=cur->_left;
			else
				return true;
		}
		return false;
	}

	bool Remove(const K& key)
	{
		Node *cur = _root;
		Node *parent = NULL;
		Node *del = NULL;
		while (cur&&cur->_key!=key)
		{
			if (cur->_key < key)
			{

				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key>key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				break;
			}
		}
		if (cur == NULL)
		{
			return false;   
		}
		if (cur->_left == NULL)
		{

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

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

		}
		else
		{
			Node *minright = cur->_right;
			while (minright->_left)
			{
				parent = minright;
				minright = minright->_left;
			}
			del = minright;
			cur->_key = minright->_key;


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

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

bool FindR(Node *& root , const K& key)
{
	if (root == NULL)
	{
		return false;
	}
	if (root->_key < key)
	{
		return FindR(root->_right,key)
	}
	else if (root->_key > key)
	{
		return FindR(root->_left,key)
	}
	else
		return true;
}



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

	bool _RemoveR(Node *&root , const K& key)
	{
		if (root ==NULL)
		{
			return false;
		}
		if (root->_key < key)
		{
			return _RemoveR(root->_right,key);
		}
		else if (root->_key > key)
		{
			return _RemoveR(root->_left,key);
		}
		else
		{
			Node* del=root;
			if (root->_left == NULL)
			{
				root = root->_right;
			}
			else if (root->_right == NULL)
			{
				root = root->_left;
			}
			else
			{
				Node* parent = root;
				Node * minright = root->_right;
				while (minright->_left)
				{
					parent = minright;
					minright = minright->_left;
				}
				root->_key = minright->_key;
//
				if (parent->_right == minright)
					parent->_right = minright->_right;
				else
					parent->_left = minright->_right;
				del = minright;
			}
			delete del;
			return true;
		}
		return false;
	}

protected:
	Node *_root;
};

void test()
{
	int arr[]={5,3,4,1,7,8,2,6,0,9};
	size_t size=sizeof(arr)/sizeof(arr[0]);
	SearchBinaryTree<int> sbt;
	for (size_t i=0;i<size;i++)
	{
		sbt.Insert(arr[i]);
	}
	sbt.InOrder();
	sbt.Insert(1);
	sbt.Insert(10);
	sbt.InOrder();
	cout<<sbt.Find(1)<<endl;
	cout<<sbt.Find(7)<<endl;
	cout<<sbt.Find(20)<<endl;
	sbt.Remove(0);
	sbt.Remove(1);
	sbt.Remove(2);
	sbt.Remove(3);
	sbt.Remove(4);
    sbt.Remove(5);
	sbt.InOrder();
	sbt.Remove(6);
	sbt.Remove(7);
	sbt.Remove(8);
	sbt.Remove(9);
	sbt.InOrder();
	sbt.Remove(10);
	sbt.InOrder();
}

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


qq_33417547
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树实现
突破吧！次元壁
07-18 110
import java.util.ArrayList; import java.util.NoSuchElementException; import java.util.Random; public class forTest { public static void main(String[] args) { SearchBinaryTree t = new SearchBinaryTree(); Random r =new Random();
二叉树的实现
qq_50743381的博客
05-27 1390
二叉树 1、二叉树结构简介 在进行链表结构开发的过程之中会发现所有的数据按照首尾相连的状态进行保存，那么当要进行某一个数据查询的时候（判断该数据是否存在），这种情况下它所面对的时间复杂度是“O(n)”，如果说现在它的数据量小，这样的情况下，性能上是不会有太大差别的，但是一旦保存的数据量很大，这个时候时间负责度就会严重很多，严重损耗程序的运行性能。这个时候对于数据的存储结构就必须发生改变，应该可以尽可能的减少检索次数为出发点进行设计，对于现在的数据结构而言，最好的性能就是“O(logn)”。所以要想实现它就可
【数据结构】—搜索二叉树（C++实现，超详细！）
B1ue还在专注
11-24 2526
本文是作者学习搜索二叉树时对于搜索二叉树知识点的总结以及模拟实现，可能还不够全面，但是作者已经尽力了，毕竟超万字了Ｏ（≧口≦）Ｏ
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
Python实现二叉搜索树
09-21
在Python中实现二叉搜索树，通常会定义两个类：`BinarySearchTree`和`TreeNode`。`BinarySearchTree`是整个树的容器，它有一个`TreeNode`类型的根节点，并且包含了一些基本操作，如`__init__`构造函数用于初始化空树...
Java二叉搜索树基础原理与实现方法详解
08-19
Java二叉搜索树基础原理与实现方法详解 本文详细介绍了Java二叉搜索树的基础原理与实现方法，涵盖了二叉树的定义、特点、二叉搜索树的定义、性质、思想、编程实现等方面的知识点。 一、树的定义 树是n（n>=0）个...
二叉查找树的具体实现-java
10-29
树集合了数组（查找速度快）和链表（插入、删除速度快）的优点； 二叉搜索树的效率： 树的大部分操作需要从上至下一层层的查找树的节点，对于一棵满树，大约有一半的节点处于最底层（最底层节点数 = 其它层节点数的和 + 1），故节点操作大约有一半需要找到最底层节点，大约有四分之一的节点处于倒数第二层，故节点操作大约有四分之一需要找到倒数第二层节点，依此类推；查找过程中，需要访问每一层的节点，故只要知道了查找的层数，就能知道操作所需的时间，如果节点总数为N，层数为L，L=log2(N+1)；
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
基于二叉搜索树实现的电话簿程序
11-10
《基于二叉搜索树实现的电话簿程序》 在计算机科学中，数据结构是存储和组织数据的关键方式，而二叉搜索树（Binary Search Tree，BST）作为一种特殊的数据结构，因其高效的操作性能在各种实际应用中得到广泛使用。...
javascript数据结构之二叉搜索树实现方法
10-23
主要介绍了javascript数据结构之二叉搜索树实现方法,较为详细的分析了二叉搜索树的概念、原理与JavaScript实现二叉搜索树的方法,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下
二叉搜索树（二叉排序树，二叉查找树）（附图详解+代码实现+应用分析）
最新发布
2301_77509762的博客
03-25 2503
二叉搜索树，二叉搜索树的概念，二叉搜索树的操作（含思路分析+代码实现），二叉搜索树的查找（递归实现看最后总代码），二叉搜索树的插入（递归实现看最后总代码），二叉搜索树的删除（递归实现看最后总代码，总代码（含递归实现）：，二叉搜索树的应用，二叉搜索树的性能分析
【数据结构】二叉搜索树/搜索二叉树(C++实现)
Brant_zero的博客
11-05 2161
二叉搜索树的概念、二叉搜索树的实现，二叉搜索树的插入、二叉搜索树的删除、二叉搜索树的查找、二叉搜索树性能分析，二叉搜索树key模型、二叉搜索树key-value模型
二叉搜索树 的实现
qq_55164622的博客
09-23 316
什么是二叉搜索树？二叉搜索树有什么特性？二叉搜索树是怎样实现的？ （1）二叉搜索树 又称二叉查找树、二叉排序树，顾名思义二叉搜索树的查找效率非常的高，而且二叉搜索树要满足二叉树的结构特性故每个根节点最多只有两个叶子节点。这的二叉搜索树和前面学的堆的结构也是相似的。 ...
二叉搜索树详解与实现
a1912157861的博客
01-09 601
二叉搜索树详解与实现二叉搜索树概念二叉树的增删查改K类型二叉搜索树和KV类型二叉搜索树的底层代码实现 二叉搜索树概念 二叉搜索树又称二叉排序树，它具有以下这几种性质: 如果它的左子树不为空，则左子树上所有节点的值都小于根节点的值 如果它的右子树不为空，则右子树上所有节点的值都大于根节点的值 他的左右子树都是二叉搜索树 那么它为什么要叫做二叉排序树呢？ 因为它的中序遍历就是一个有序的数列，所以我们一般用中序遍历来遍历二叉搜索树，并且也可以使用二叉搜索树的这个特性来检查当前二叉树是否是二叉搜索树。 二叉树的
java 二叉搜索树实现
12-08
以下是Java实现二叉搜索树的基本步骤和代码示例： 1.定义二叉搜索树节点类 ```java class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } ``` 2.定义二叉搜索树类 ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值