超详细的二叉搜索树讲解 附完整代码递归+非递归

最新推荐文章于 2019-07-22 22:04:06 发布
最新推荐文章于 2019-07-22 22:04:06 发布
阅读量5.3k 收藏 1
点赞数 2
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37419449/article/details/79525226
版权

二叉搜索树

概念

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

从图中可以直观看见，右子树节点值大于左子树节点值，且中序遍历是按一定顺序排列。

原理

二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。中序遍历二叉排序树可得到一个关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即为对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。搜索,插入,删除的复杂度等于树高，O(log(n)).

操作
template<class T>//定义结点的结构体
struct Node
{
	typedef struct Node* _pNode;
	_pNode _pRight;
	_pNode _pLeft;
	T _data;
public:
	Node(T data)
		:_pRight(NULL)
		,_pLeft(NULL)
	{
		_data = data;
	}
	Node()
		:_pRight(NULL)
		,_pLeft(NULL)
	{
		_data = T();
	}

};

1.插入

先判断插入节点值大于根节点，若大于插入右子树，小于插入左子树。

//非递归
	bool _Insert(const T data)
	{
		_pNode pCur = _Root;
		_pNode pParent = NULL;
		if(_Root != NULL)
		{
			while(pCur)
			{
				pParent = pCur;
				if(pCur->_data > data)
				{
					pCur = pCur->_pLeft;
				}
				else if(pCur->_data < data)
				{
					pCur = pCur->_pRight;
				}
				else
				{
					return false;
				}
			}
			if(pParent != NULL)
			{
				if(pParent->_data < data)
				{
					pParent->_pRight = new _Node(data);
				}
				else
				{
					pParent->_pLeft = new _Node(data);
				}
				return true;
			}
			return false;
		}
		else
		{
			_Root =  new _Node(data);
			return true;
		}
	}
//递归
	bool Insert(const T data)
	{
		return _recInsert(_Root, data);
	}
        bool _recInsert(_pNode& pCur, const T data)
	{
		if(pCur == NULL)
		{
			pCur = new _Node(data);
			return true;
		}

		if(pCur->_data > data)
		{
			return _recInsert(pCur->_pLeft, data);
		}
		else if(pCur->_data < data)
		{
			return _recInsert(pCur->_pRight, data);
		}
		else
		{
			return false;
		}
	}

2.查找

原理：类似于插入

	//非递归
	_pNode _find(const T& data)
	{
		_pNode pCur = _Root;
		while(pCur)
		{
			if(pCur->_data == data)
				return pCur;
			else if(pCur->_data > data)
			{

				pCur = pCur->_pLeft;
			}
			else
			{
				pCur = pCur->_pRight;
			}
		}
		return NULL;
	}
//递归
_pNode Find(const T data)
	{
		return _recFind(_Root, data);
	}
_pNode _recFind(_pNode& pCur, const T data)
	{
		if(pCur->_data == data)
		{
			return pCur;
		}

		if(pCur->_data > data)
		{
			return _recFind(pCur->_pLeft, data);
		}
		else if(pCur->_data < data)
		{
			return _recFind(pCur->_pRight, data);
		}
		else
		{
			return NULL;
		}
	}

3.删除

删除分为三种情况：

1.删除仅有左子树节点；

2.删除仅有右子树节点；

3.删除既有左子树又有右子树节点；

其中叶子节点的情况可包含在1或者2情况中；

**********************************************************************************

1.删除仅有左子树节点：

当删除C节点时，可以直接将指向C的节点直接指向C的左子树；

2.删除仅有右子树节点：


当删除I节点时，可以直接将指向I的节点直接指向I的右子树；

3.删除既有左子树又有右子树节点：


a.删除左子树上的结点（例如D）

保存D的左子树，指向D的结点指向D的右子树，在让现在D的左子树的叶子节点指向之前保存D的左子树。

b.删除右子树上的结点（例如H）

保存H的右子树，指向H的结点指向H的右子树，在让现在H的左子树的叶子节点指向之前保存H的左子树。

c.删除根结点（例如F）

保存F的左子树，根节点变成根节点的右子树，在让现在F的左子树的叶子节点指向之前保存F的左子树。

 //非递归
	bool _delete(const T& data)
	{
		_pNode pCur = _Root;
		_pNode pParent = NULL;
		while(pCur)
		{
			if(pCur->_data < data)
			{
				pParent = pCur;
				pCur = pCur->_pRight;
			}
			else if(pCur->_data > data)
			{
				pParent = pCur;
				pCur = pCur->_pLeft;
			}
			else
			{
				break;
			}
		}
		if(pCur == NULL)
		{
			return false;
		}
		if(pCur->_pRight == NULL)
		{
			pParent->_pLeft = pCur->_pLeft;
			delete pCur;
		}
		else if(pCur->_pLeft == NULL)
		{
			pParent->_pRight = pCur->_pRight;
			delete pCur;
		}
		else
		{
			if(pParent != NULL)
			{
				if(pParent->_pLeft->_data == data)
				{
					pParent->_pLeft = pCur->_pRight;
				}
				else
				{
					pParent->_pRight = pCur->_pRight;
				}
				_pNode tempLeft = pCur->_pLeft;
				_pNode newdel = pCur->_pRight;
				while(newdel->_pLeft != NULL)
				{
					newdel =  newdel->_pLeft;
				}
				newdel->_pLeft = tempLeft;
				delete pCur;
			}
			else
			{
				_pNode tempLeft = pCur->_pLeft;
				_Root = _Root->_pRight;
				_pNode tempRight = _Root;
				while(tempRight->_pLeft != NULL)
				{
					tempRight =  tempRight->_pLeft;
				}
				tempRight->_pLeft = tempLeft;
				delete pCur;
			}
		}

	}

//递归
bool Delete(const T data)
	{
		return _recDelete(_Root, data);
	}
bool _recDelete(_pNode& pCur, const T data)
	{
		if(pCur->_data == data)
		{
			if(NULL == pCur->_pRight)
			{
				_pNode del = pCur;
				pCur = pCur->_pLeft;
				delete pCur;
				return true;
			}
			else if(NULL == pCur->_pLeft)
			{
				_pNode del = pCur;
				pCur = pCur->_pRight;
				delete pCur;
				return true;
			}
			else
			{
				_pNode del = pCur->_pRight;
				while(del->_pLeft)
				{
					del = del->_pLeft;
				}
				pCur->_data = del->_data;
				return _recDelete(pCur->_pRight, del->_data);
			}
		}

		if(pCur->_data > data)
		{
			return _recDelete(pCur->_pLeft, data);
		}
		else if(pCur->_data < data)
		{
			return _recDelete(pCur->_pRight, data);
		}
		else
		{
			return false;
		}
	}

完整代码：

#include <iostream>
using namespace std;

template<class T>
struct Node
{
	typedef struct Node* _pNode;
	_pNode _pRight;
	_pNode _pLeft;
	T _data;
public:
	Node(T data)
		:_pRight(NULL)
		,_pLeft(NULL)
	{
		_data = data;
	}
	Node()
		:_pRight(NULL)
		,_pLeft(NULL)
	{
		_data = T();
	}

};

template<class T>
class BSTree
{
	typedef struct Node<T> _Node;
	typedef struct Node<T>*  _pNode;
public:
	BSTree()
	{
		_Root = NULL;
	}


	void _Inorder()
	{
		Inorder(_Root);
	}

	
	//非递归
	bool _Insert(const T data)
	{
		_pNode pCur = _Root;
		_pNode pParent = NULL;
		if(_Root != NULL)
		{
			while(pCur)
			{
				pParent = pCur;
				if(pCur->_data > data)
				{
					pCur = pCur->_pLeft;
				}
				else if(pCur->_data < data)
				{
					pCur = pCur->_pRight;
				}
				else
				{
					return false;
				}
			}
			if(pParent != NULL)
			{
				if(pParent->_data < data)
				{
					pParent->_pRight = new _Node(data);
				}
				else
				{
					pParent->_pLeft = new _Node(data);
				}
				return true;
			}
			return false;
		}
		else
		{
			_Root =  new _Node(data);
			return true;
		}
	}

	//非递归
	_pNode _find(const T& data)
	{
		_pNode pCur = _Root;
		while(pCur)
		{
			if(pCur->_data == data)
				return pCur;
			else if(pCur->_data > data)
			{

				pCur = pCur->_pLeft;
			}
			else
			{
				pCur = pCur->_pRight;
			}
		}
		return NULL;
	}
    //非递归
	bool _delete(const T& data)
	{
		_pNode pCur = _Root;
		_pNode pParent = NULL;
		while(pCur)
		{
			if(pCur->_data < data)
			{
				pParent = pCur;
				pCur = pCur->_pRight;
			}
			else if(pCur->_data > data)
			{
				pParent = pCur;
				pCur = pCur->_pLeft;
			}
			else
			{
				break;
			}
		}
		if(pCur == NULL)
		{
			return false;
		}
		if(pCur->_pRight == NULL)
		{
			pParent->_pLeft = pCur->_pLeft;
			delete pCur;
		}
		else if(pCur->_pLeft == NULL)
		{
			pParent->_pRight = pCur->_pRight;
			delete pCur;
		}
		else
		{
			if(pParent != NULL)
			{
				if(pParent->_pLeft->_data == data)
				{
					pParent->_pLeft = pCur->_pRight;
				}
				else
				{
					pParent->_pRight = pCur->_pRight;
				}
				_pNode tempLeft = pCur->_pLeft;
				_pNode newdel = pCur->_pRight;
				while(newdel->_pLeft != NULL)
				{
					newdel =  newdel->_pLeft;
				}
				newdel->_pLeft = tempLeft;
				delete pCur;
			}
			else
			{
				_pNode tempLeft = pCur->_pLeft;
				_Root = _Root->_pRight;
				_pNode tempRight = _Root;
				while(tempRight->_pLeft != NULL)
				{
					tempRight =  tempRight->_pLeft;
				}
				tempRight->_pLeft = tempLeft;
				delete pCur;
			}
		}

	}

//递归
	bool Insert(const T data)
	{
		return _recInsert(_Root, data);
	}
	_pNode Find(const T data)
	{
		return _recFind(_Root, data);
	}
	bool Delete(const T data)
	{
		return _recDelete(_Root, data);
	}

private:
	bool _recDelete(_pNode& pCur, const T data)
	{
		if(pCur->_data == data)
		{
			if(NULL == pCur->_pRight)
			{
				_pNode del = pCur;
				pCur = pCur->_pLeft;
				delete pCur;
				return true;
			}
			else if(NULL == pCur->_pLeft)
			{
				_pNode del = pCur;
				pCur = pCur->_pRight;
				delete pCur;
				return true;
			}
			else
			{
				_pNode del = pCur->_pRight;
				while(del->_pLeft)
				{
					del = del->_pLeft;
				}
				pCur->_data = del->_data;
				return _recDelete(pCur->_pRight, del->_data);
			}
		}

		if(pCur->_data > data)
		{
			return _recDelete(pCur->_pLeft, data);
		}
		else if(pCur->_data < data)
		{
			return _recDelete(pCur->_pRight, data);
		}
		else
		{
			return false;
		}
	}
	_pNode _recFind(_pNode& pCur, const T data)
	{
		if(pCur->_data == data)
		{
			return pCur;
		}

		if(pCur->_data > data)
		{
			return _recFind(pCur->_pLeft, data);
		}
		else if(pCur->_data < data)
		{
			return _recFind(pCur->_pRight, data);
		}
		else
		{
			return NULL;
		}
	}
	bool _recInsert(_pNode& pCur, const T data)
	{
		if(pCur == NULL)
		{
			pCur = new _Node(data);
			return true;
		}

		if(pCur->_data > data)
		{
			return _recInsert(pCur->_pLeft, data);
		}
		else if(pCur->_data < data)
		{
			return _recInsert(pCur->_pRight, data);
		}
		else
		{
			return false;
		}
	}


private:
	void Inorder(_pNode pCur)
	{
		if(!pCur)
			return;
		Inorder(pCur->_pLeft);
		cout<<pCur->_data<<" ";
		Inorder(pCur->_pRight);
	}


private:
	_pNode _Root;
};


void TestFun()
{
	BSTree<int> tree;
	tree.Insert(5);
	tree.Insert(3);
	tree.Insert(4);
	tree.Insert(2);
	tree.Insert(1);
	tree.Insert(7);
	tree.Insert(6);
	tree.Insert(8);
	tree.Insert(9);
	tree._Inorder();
	cout<<endl;
	tree.Delete(3);
	tree._Inorder();
	cout<<endl;




}




int main()
{
	TestFun();
	return 0;
}
BugGuys
关注
专栏目录
二叉搜索树的非递归实现
melody_1016的博客
01-17 579
“折半查找”这个词相信大家在学习C语言的时候已经很熟悉，由于数组中数字的排列是有序的，那么我们就可以将要查找的数字与最中间的数进行比较，每次比较都可以把范围缩小一半，依次下去，很好的提高了查找效率。而在数据结构中，我们也有处理这种问题的对应模型------二叉搜索树（也称为二叉排序树）。 二叉搜索树的性质： （1）每个节点都有一个作为搜索依据的关键码（key）,所有节点的关键码互不相同 （2
深入学习理解二叉搜索树（附详细讲解与实例分析）
热门推荐
Hin 的博客
11-01 1万+
原创文章，转载请注明出处。本文主要分为三个部分。第一部分介绍了二叉搜索树的基本性质。第二部分全面详细地讲述了二叉搜索树的各种基本操作。第三部分则是完整的代码实现及实例分析。 对于每一种基本操作，都至少分三个重点进行讲解。它们分别是基本操作过程及原理（包含伪代码及C++实现）、时间复杂度分析以及举例分析（配图）。力求让每位读者可以直观地理解。 本文断断续续写了几天，各部分的举例分析也十分明了，为了讲得更清楚一些，所有的配图都是自行制作的。请尊重劳动成果，供人供己查阅，如有错误之处，欢迎
二叉搜索树的非递归创建和搜索
weixin_30917213的博客
05-19 98
#include "stdio.h" typedef struct node { int data ; node*lChild ; node*rChild ; }TreeNode ; void Insert(TreeNode**root,int data) //向二叉查找树中插入元素 采用非递归思想 { TreeNode * p=*root ;//获得...
二叉搜索树的非递归C++实现
weixin_33890499的博客
07-14 88
2019独角兽企业重金招聘Python工程师标准>>> ...
二叉排序树的递归与非递归查找
Jay Chang
06-29 887
#include&lt;iostream&gt; using namespace std; //定义二叉树结点 typedef struct BiTreeNode{ int value; BiTreeNode *lChild,*rChild; }BiTreeNode,*BiTree; //将结点插入为根节点的孩子结点，如果值小于根节点值，则插入到左子树 void...
二叉搜索树之非递归
dong18292000671的博客
05-23 316
二叉搜索树的定义： 1.每棵子树都有：左子树的值 < 根节点的值 < 右子树的值 2.中序遍历的结果是排序好的。 插入方法： int arr[] = {5,3,4,1,7,8,2,6,0,9}; 删除： 判断要删除的节点的孩子的情况： 代码： 定义节点#pragma once #include <iostream> #include <windows.h> using
c代码-二叉搜索树的查找操作
07-16
本篇将重点讲解如何使用C语言实现二叉搜索树的查找操作，并通过提供的`main.c`源文件和`README.txt`来深入理解这个过程。 二叉搜索树的定义是每个节点包含一个键（key）、一个关联的值、一个指向左子树的引用和一个...
二叉搜索树的增删查（递归与非递归）实现
zhuohaiyy的博客
10-23 370
二叉搜索树（BinarySearchTree）： 二叉搜索树性质： 1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。 2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。 3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）。 4. 左右子树都是二叉搜索树。如图：是一个二叉搜索树 本文将实现二叉搜索树的插入删除查找我们
算法面试通关40讲完整课件 18-20 树、二叉树、二叉搜索树
07-06
为了有效地解决这些问题，你需要熟悉二叉搜索树的遍历方法，包括前序遍历、中序遍历和后序遍历，以及递归和迭代的实现。同时，了解如何通过这些遍历来找出节点的属性，比如最大值、最小值，或者构造二叉搜索树。 **...
python入门-leetcode面试题解之第235题二叉搜索树的最近公共祖先.zip
最新发布
05-31
对于初学者，理解并实现这些代码可以帮助加深对二叉搜索树和递归/迭代遍历的理解。 解压缩这个文件后，你应该能看到一个详细讲解这个问题的Python代码实现，包括注释和可能的测试用例，这对于学习和练习非常有帮助...
二叉查找树实现代码
12-09
二叉查找树的插入、搜索、删除、寻找前驱结点、寻找后继结点
acm二叉搜索树参考代码
05-28
acm题目二叉搜索树的参考源代码，内含测试数据和源代码。
二叉搜索树（递归和非递归分别实现）
qingcunsuiyue的博客
10-21 364
这是在上一篇博客的基础上进行完善。 1.插入的递归 bool InsertR(const T& key) { return _InsertR(_root,key); } bool _InsertR(Node*& root,const T& key) { if(root==NULL) { root=new Node(key); return true; }
二叉查找树的非递归操作
u011044759的专栏
09-18 3002
昨天同学去参加阿里巴巴面试，被问到二叉树的一些基本问题，分享一下： 1.如何非递归dfs求得树的深度 2.如何非递归bfs求得树的深度 *3.如何非递归地中前后序遍历二叉查找树。 二叉树写过不下十次了，但是基本每次都是用递归来写，一时间问道还不能一下写出来。 问题二还是比较好写，一的话可能需要仔细想想，但是假如是面试的话，可能我一时也说不出来。 老实说，我自己写得代码总得看来是满长的，
【数据结构】 二叉搜索树的模拟实现——完整代码
ly_6699的博客
05-02 1084
二叉搜索树是支持set和map 实现的底层结构。 在上篇博客 二叉搜索树中，我详细讲到过。 这里我主要完成二叉搜索树的完整代码中包含的几个接口： 构造函数，析构函数，拷贝构造，赋值重载，查找，插入，删除，打印 及测试过程。 BSTree.h #define _CRT_SECURE_NO_WARNINGS 1 # pragma once #include <stdlib.h> #incl...
二叉搜索树---递归及非递归
hm108106的博客
05-23 371
二叉搜索树又称为二叉排序树，它为一棵空树，或者是一棵左子树所有节点的值比根节点小，右子树所有节点的值比根节点大的一棵树。 性质： ①.二叉搜索树中，最左边的结点值最小，最右边的结点值最大 ②中序遍历一棵二叉搜索树，所有节点的值是按顺序排列的 构造一棵二叉搜索树时，比较插入结点的key值，key小于根节点的_key时，向根节点的左边走，大于根节点的_key值时，向根节点的右边
二叉查找树之——非递归实现
naw0011的专栏
10-30 1144
上一一篇文章介绍了二叉查找树的递归实现，递归算法以简洁明了，便于阅读与理解，但是只要是与递归有关，就少不了递归调用栈，也就是函数栈，这会导致栈溢出。假如递归层次达到10000次，程序就崩溃了，二叉查找树当插入的节点是升序或者逆序，就形成了链表，这样就形成了10000层递归。并且，递归没有非递归效率高，语音在于函数调用会相对耗时。所以非递归算法在安全性和效率上更实用。下面对二叉查找操作的非递归算法实
二叉树的遍历（递归和非递归的方法）
hopegrace的博客
07-22 748
一.使用递归的方法进行二叉树的遍历 二叉树是一种非常重要的数据结构，很多其他数据机构都是基于二叉树的基础演变过来的。二叉树有前、中、后三种遍历方式，因为树的本身就是用递归定义的，因此采用递归的方法实现三种遍历，不仅代码简洁且容易理解，但其开销也比较大，而若采用非递归方法实现三种遍历，则要用栈来模拟实现（递归也是用栈实现的）。 三种遍历方式的递归实现 1、先序遍历——按照“根节点-左孩子...
二叉搜索树的递归遍历和非递归遍历
走好每一步！
03-26 567
递归遍历 void preOrder(TreeNode *root){ if(!root) return; cout << root->val << endl; preOrder(root->left); preOrder(root->right); } void inOrder(TreeNode *root){ if(!root) return
二叉搜索树原理与应用——数控机床G代码M代码关联分析
邓俊辉教授的《数据结构（C++语言版）》第三版详细介绍了这些概念，并提供了相关的代码示例和习题，帮助读者理解和掌握二叉搜索树的原理和实现。这本书是清华大学985名优教材立项资助的一部分，旨在提供高质量的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BugGuys

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值