AVLBinTree(二叉平衡树)

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

由于二叉搜索树的不平衡性会导致搜索的效率降低（比如单支情况），所以在将二叉搜索树升级改造成为了二叉平衡树。

AVL树是一个“加上了额外平衡条件”的二叉搜索树，其平衡为为了保持整个树的深度为O（logN）,直观上的最佳平衡状态是每个节点的左右子树的高度相同，但是这个条件过于严苛，所以AVL树退而求次之，它的要求就是任何节点 的左右子树高度相差最多1，虽然这是一个比较弱的条件，但是足够保持树的平衡了。

所以说二叉平衡树只是二叉搜索树的基础上加入了平衡因子而改造而来的。

1.首先给出树的定义的结点，注意和搜索树有所不同，里面多了平衡因子_bf和指向父结点的指针（调整保持平衡性的时候要用）

template<class K,class V>
struct AVLBinTreeNode
{
	AVLBinTreeNode<K, V> *_pLeft;
	AVLBinTreeNode<K, V>* _pRight;
	AVLBinTreeNode<K, V>* _pParent;
	K _key;
	V _value;
	int _bf;
	AVLBinTreeNode(const K& key, const V& value)
		:_pLeft(NULL)
		, _pRight(NULL)
		, _pParent(NULL)
		, _key(key)
		, _value(value)
		, _bf(0){}
};
2.插入和二叉搜索树的插入一样，只不过插入完了以后要计算出每个结点的平衡因子，并且根据平衡因子判断是否平衡，如果不平衡则需要调整（专业的来说就是旋转）

举个例子说明问题：

可以看出插入结点11这个结点以后，这个结点违反了AVL的平衡条件，由于只有“插入结点至根节点”路径上的各节点可能改变平衡状态，因此只需要调整其中最深的那个结点，可使整个树重新获得平衡。假设该最深的结点为X，由于结点最多拥有两个子节点，而所谓“平衡被破坏”意味着X的左右两棵子树的高度相差2，所以通过这个结论我们可以将插入的结点分为如下四四种情况

1.插入点位于X的左子结点的左子树上----->左左

2.插入点位于X的右子结点的右子树上----->右右

3.插入点位于X的左子结点的右子树上----->左右

4.插入点位于X的右子结点的左子树上----->右左

对于这四种情况你先脑子里大概想一下，下面我来一个一个介绍

1.左左使用右单旋


2.右右使用左单旋


3.左右，先左旋在右旋（双旋）


4.右左，先右旋在左旋（双旋）

这里就不列举了，因为他和左右也是一致对称的。留给你自己去画图了！


再次强调一遍：想学会AVL的树的旋转，需要明白1.插入一个结点后会导致这个结点从下向上的一条路径上的所有的结点的平衡状态都有可能改变，2.只需要调节那个最深的结点就可以使树平衡，这里的最深的结点的标志就是平衡因子等于2。。。。3.因为每个结点最多就一个左子节点一个右子节点，如果没有插入的话是平衡的，一旦插入要么在左子结点的左子树，要么在左子结点的右子树，要么在右子结点的右子树上，要么在右子节点的左子树上，就是上面所说的四种情况。自己好好画图理解。


下面给出每个旋转的代码自己也可以结合代码去理解

1.左旋代码

void _RotateL(PNode pParent)//左旋
	{
		PNode SubR = pParent->_pRight;
		PNode SubRL = SubR->_pLeft;
		pParent->_pRight = SubRL;
		if (SubRL)
		{
			SubRL->_pParent = pParent;
		}
		PNode ppNode =pParent->_pParent;
		SubR->_pLeft = pParent;
		pParent->_pParent = SubR;
		if (ppNode == NULL)
		{
			_pRoot = SubR;
			SubR->_pParent = NULL;
		}
		else
		{
			if (ppNode->_pLeft == pParent)
			{
				ppNode->_pLeft = SubR;
			}
			else
			{
				ppNode->_pRight = SubR;
			}
			SubR->_pParent = ppNode;
		}
		pParent->_bf=SubR->_bf = 0;
	}
2.右旋代码 

void _RotateR(PNode pParent)
	{
		PNode SubL = pParent->_pLeft;
		PNode SubLR = SubL->_pRight;
		pParent->_pLeft = SubLR;
		if (SubLR)
		{
			SubLR->_pParent = pParent;
		}
		PNode ppNode = pParent->_pParent;
		SubL->_pRight = pParent;
		pParent->_pParent = SubL;
		if (ppNode == NULL)
		{
			_pRoot = SubL;
			SubL->_pParent = NULL;
		}
		else
		{
			if (ppNode->_pLeft == pParent)
			{
				ppNode->_pLeft = SubL;
				SubL->_pParent = ppNode;
			}
			else
			{
				ppNode->_pRight = SubL;
				SubL->_pParent = ppNode;
			}
		}
		pParent->_bf = SubL->_bf = 0;
	}
3.左右旋代码 

	void _RotateLR(PNode pParent)
	{
		PNode SubL = pParent->_pLeft;
		PNode SubLR = SubL->_pRight;
		int bf = SubLR->_bf;
		_RotateL(SubL);
		_RotateR(pParent);
		if (bf == 0)//如果bf是0等于插入结点就是SubLR,这个时候所有旋转的bf都是0
		{
			SubL->_bf = pParent->_bf = 0;
		}
		else if (bf == -1)//在 bf的左子树树插入新结点
		{
			SubL->_bf = -1;
			pParent->_bf = 0;
		}
		else//新结点的右子树树插入结点
		{
			SubL->_bf = 0;
			pParent->_bf = -1;
		}
		SubLR->_bf = 0;
 	}
4.右左旋代码 

void _RotateRL(PNode pParent)
	{
		PNode SubR = pParent->_pRight;
		PNode SubRL= SubR->_pLeft;
		int bf = SubRL->_bf;
		_RotateR(SubR);
		_RotateL(pParent);
		if (bf == 0)//如果bf是0等于插入结点就是SubLR,这个时候所有旋转的bf都是0
		{
			SubR->_bf = pParent->_bf = 0;
		}
		else if (bf == -1)//在 bf的左子树树插入新结点
		{
			SubR->_bf = 0;
			pParent->_bf = -1;
		}
		else//新结点的右子树树插入结点
		{
			SubR->_bf = -1;
			pParent->_bf = 0;
		}
		SubRL->_bf = 0;
	}
下面给出AVL树的插入代码，融合了平衡调整 

bool Insert(const K& key, const V& value)
	{
		if (_pRoot == NULL)
		{
			_pRoot = new Node(key, value);
			return true;
		}
		PNode pParent = NULL;
		PNode cur = _pRoot;
		while (cur)//找位置
		{
			if (cur->_key == key)
				return false;
			else if (cur->_key > key)
			{
				pParent = cur;
				cur = cur->_pLeft;
			}
			else
			{
				pParent = cur;
				cur = cur->_pRight;
			}
		}
		PNode pNewNode = new Node(key, key);
		if (pParent->_key > key)
		{
			pParent->_pLeft = pNewNode;
		    pNewNode->_pParent = pParent;
		}
		else
		{
			pParent->_pRight = pNewNode;
			pNewNode->_pParent = pParent;
		}
		//插入以后要开始调整
		while (pParent)
		{
			//首先计算父结点平衡因子
			if (pParent->_pLeft == pNewNode)//插入在当前结点的左边则bf--
			{
				pParent->_bf--;
			}
			else
			{
				pParent->_bf++;
			}
			//根据父结点平衡因子判断是否需要调整
			if (pParent->_bf == 0)//平衡
			{
				return true;
			}
			else  if (pParent->_bf==1||pParent->_bf==-1)//也是平衡,往回找判断
			{
				pNewNode = pParent;
				pParent = pParent->_pParent;
			}
			else if (pParent->_bf == 2 || pParent->_bf == -2)
			{
				if (pParent->_bf == 2)//左边的结点比较多
				{
					if (pNewNode->_bf == 1)
					{
						_RotateL(pParent);//
						return true;
					}
					else
					{
						_RotateRL(pParent);//右左旋转
						return true;
					}
				}
				if (pParent->_bf == -2)
				{
					if (pNewNode->_bf == -1)
					{
						_RotateR(pParent);
						return true;
					}
					else
					{
						_RotateLR(pParent);
						return true;
					}
				}
			}
		}
		return true;
	}

剩下的关于AVL树的就没有什么值得多花时间去啰嗦了下面我将直接给出代码，分别有1.判断平衡树是否平衡，2.求平衡树的高度，3中序遍历平衡二叉树 
void _InOrder(PNode pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << pRoot->_key << " ";
			_InOrder(pRoot->_pRight);
		}
	}
	bool _IsBalance_one(PNode pRoot)
	{
		if (pRoot == NULL)
		{
			return true;
		}
		int height = abs(_Height(pRoot->_pRight) - _Height(pRoot->_pLeft));
		return (height < 2 )&& _IsBalance_one(pRoot->_pLeft) && _IsBalance_one(pRoot->_pRight);
	}
	bool _IsBalance_two(PNode pRoot,int &depth)//自下向上的方法
	{
		if (NULL == pRoot)
		{
			depth = 0;
			return true;
		}
		int leftDepth, rightDepth;
		if (_IsBalance_two(pRoot->_pLeft, leftDepth) == false)
		{
			return false;
		}
		if (_IsBalance_two(pRoot->_pRight, rightDepth) == false)
		{
			return false;
		}
		if (rightDepth - leftDepth != pRoot->_bf)
		{
			cout << "bf异常" << pRoot->_bf << endl;
		}
		depth = leftDepth > rightDepth ? (leftDepth + 1) : (rightDepth + 1);
		return true;
	}
	int _Height(PNode pRoot)
	{
		if (NULL == pRoot)
		{
			return 0;
		}
		int lheight = _Height(pRoot->_pLeft) + 1;//求出左子树的高度
		int rheight = _Height(pRoot->_pRight) + 1;//求出右子树的高度
		return lheight > rheight ? lheight : rheight;
	}

下面给出完整的代码包括测试案例 

#include<iostream>
using namespace std;
template<class K,class V>
struct AVLBinTreeNode
{
	AVLBinTreeNode<K, V> *_pLeft;
	AVLBinTreeNode<K, V>* _pRight;
	AVLBinTreeNode<K, V>* _pParent;
	K _key;
	V _value;
	int _bf;
	AVLBinTreeNode(const K& key, const V& value)
		:_pLeft(NULL)
		, _pRight(NULL)
		, _pParent(NULL)
		, _key(key)
		, _value(value)
		, _bf(0){}
};
template<class K,class V>
class AVLBinTree
{
public:
	typedef AVLBinTreeNode<K, V> Node;
	typedef Node* PNode;
private:
	PNode _pRoot;
public:
	AVLBinTree()
		:_pRoot(NULL){}
	bool Insert(const K& key, const V& value)
	{
		if (_pRoot == NULL)
		{
			_pRoot = new Node(key, value);
			return true;
		}
		PNode pParent = NULL;
		PNode cur = _pRoot;
		while (cur)//找位置
		{
			if (cur->_key == key)
				return false;
			else if (cur->_key > key)
			{
				pParent = cur;
				cur = cur->_pLeft;
			}
			else
			{
				pParent = cur;
				cur = cur->_pRight;
			}
		}
		PNode pNewNode = new Node(key, key);
		if (pParent->_key > key)
		{
			pParent->_pLeft = pNewNode;
		    pNewNode->_pParent = pParent;
		}
		else
		{
			pParent->_pRight = pNewNode;
			pNewNode->_pParent = pParent;
		}
		//插入以后要开始调整
		while (pParent)
		{
			//首先计算父结点平衡因子
			if (pParent->_pLeft == pNewNode)//插入在当前结点的左边则bf--
			{
				pParent->_bf--;
			}
			else
			{
				pParent->_bf++;
			}
			//根据父结点平衡因子判断是否需要调整
			if (pParent->_bf == 0)//平衡
			{
				return true;
			}
			else  if (pParent->_bf==1||pParent->_bf==-1)//也是平衡,往回找判断
			{
				pNewNode = pParent;
				pParent = pParent->_pParent;
			}
			else if (pParent->_bf == 2 || pParent->_bf == -2)
			{
				if (pParent->_bf == 2)//左边的结点比较多
				{
					if (pNewNode->_bf == 1)
					{
						_RotateL(pParent);//
						return true;
					}
					else
					{
						_RotateRL(pParent);//右左旋转
						return true;
					}
				}
				if (pParent->_bf == -2)
				{
					if (pNewNode->_bf == -1)
					{
						_RotateR(pParent);
						return true;
					}
					else
					{
						_RotateLR(pParent);
						return true;
					}
				}
			}
		}
		return true;
	}
	void _RotateL(PNode pParent)//左旋
	{
		PNode SubR = pParent->_pRight;
		PNode SubRL = SubR->_pLeft;
		pParent->_pRight = SubRL;
		if (SubRL)
		{
			SubRL->_pParent = pParent;
		}
		PNode ppNode =pParent->_pParent;
		SubR->_pLeft = pParent;
		pParent->_pParent = SubR;
		if (ppNode == NULL)
		{
			_pRoot = SubR;
			SubR->_pParent = NULL;
		}
		else
		{
			if (ppNode->_pLeft == pParent)
			{
				ppNode->_pLeft = SubR;
			}
			else
			{
				ppNode->_pRight = SubR;
			}
			SubR->_pParent = ppNode;
		}
		pParent->_bf=SubR->_bf = 0;
	}
	void _RotateR(PNode pParent)
	{
		PNode SubL = pParent->_pLeft;
		PNode SubLR = SubL->_pRight;
		pParent->_pLeft = SubLR;
		if (SubLR)
		{
			SubLR->_pParent = pParent;
		}
		PNode ppNode = pParent->_pParent;
		SubL->_pRight = pParent;
		pParent->_pParent = SubL;
		if (ppNode == NULL)
		{
			_pRoot = SubL;
			SubL->_pParent = NULL;
		}
		else
		{
			if (ppNode->_pLeft == pParent)
			{
				ppNode->_pLeft = SubL;
				SubL->_pParent = ppNode;
			}
			else
			{
				ppNode->_pRight = SubL;
				SubL->_pParent = ppNode;
			}
		}
		pParent->_bf = SubL->_bf = 0;
	}
	void _RotateLR(PNode pParent)
	{
		PNode SubL = pParent->_pLeft;
		PNode SubLR = SubL->_pRight;
		int bf = SubLR->_bf;
		_RotateL(SubL);
		_RotateR(pParent);
		if (bf == 0)//如果bf是0等于插入结点就是SubLR,这个时候所有旋转的bf都是0
		{
			SubL->_bf = pParent->_bf = 0;
		}
		else if (bf == -1)//在 bf的左子树树插入新结点
		{
			SubL->_bf = -1;
			pParent->_bf = 0;
		}
		else//新结点的右子树树插入结点
		{
			SubL->_bf = 0;
			pParent->_bf = -1;
		}
		SubLR->_bf = 0;
 	}
	void _RotateRL(PNode pParent)
	{
		PNode SubR = pParent->_pRight;
		PNode SubRL= SubR->_pLeft;
		int bf = SubRL->_bf;
		_RotateR(SubR);
		_RotateL(pParent);
		if (bf == 0)//如果bf是0等于插入结点就是SubLR,这个时候所有旋转的bf都是0
		{
			SubR->_bf = pParent->_bf = 0;
		}
		else if (bf == -1)//在 bf的左子树树插入新结点
		{
			SubR->_bf = 0;
			pParent->_bf = -1;
		}
		else//新结点的右子树树插入结点
		{
			SubR->_bf = -1;
			pParent->_bf = 0;
		}
		SubRL->_bf = 0;
	}
	void InOrder()
	{
		_InOrder(_pRoot);
	}
	bool IsBalance_one()//判断是否为平衡二叉树
	{
		return _IsBalance_one(_pRoot);
	}
	bool IsBalance_two()
	{
		int depth;
		return _IsBalance_two(_pRoot,depth);
	}
	int Height()//求树的高度
	{
		return _Height(_pRoot);
	}
private:
	void _InOrder(PNode pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << pRoot->_key << " ";
			_InOrder(pRoot->_pRight);
		}
	}
	bool _IsBalance_one(PNode pRoot)
	{
		if (pRoot == NULL)
		{
			return true;
		}
		int height = abs(_Height(pRoot->_pRight) - _Height(pRoot->_pLeft));
		return (height < 2 )&& _IsBalance_one(pRoot->_pLeft) && _IsBalance_one(pRoot->_pRight);
	}
	bool _IsBalance_two(PNode pRoot,int &depth)//自下向上的方法
	{
		if (NULL == pRoot)
		{
			depth = 0;
			return true;
		}
		int leftDepth, rightDepth;
		if (_IsBalance_two(pRoot->_pLeft, leftDepth) == false)
		{
			return false;
		}
		if (_IsBalance_two(pRoot->_pRight, rightDepth) == false)
		{
			return false;
		}
		if (rightDepth - leftDepth != pRoot->_bf)
		{
			cout << "bf异常" << pRoot->_bf << endl;
		}
		depth = leftDepth > rightDepth ? (leftDepth + 1) : (rightDepth + 1);
		return true;
	}
	int _Height(PNode pRoot)
	{
		if (NULL == pRoot)
		{
			return 0;
		}
		int lheight = _Height(pRoot->_pLeft) + 1;//求出左子树的高度
		int rheight = _Height(pRoot->_pRight) + 1;//求出右子树的高度
		return lheight > rheight ? lheight : rheight;
	}

};
int main()
{
	int a[] = {18,14,20,12,16,15};
	AVLBinTree< int, int> bst;
	for (int i = 0; i < sizeof(a) / sizeof(*a); ++i)
	{
		bst.Insert(a[i], i);
	}
	bst.InOrder();
	cout << bst.Height();
	cout << bst.IsBalance_one();
	cout << bst.IsBalance_two();
	system("pause");
	return 0;
}
代码已经上传至github： github 链接

IT_iverson
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树实例
ay_一起沉默 的博客
08-27 4316
二叉树： 二叉树性质： 1.第i层的节点总数最多有2i-1个结点 2.深度额我k的二叉树最多有2k-1个结点，最少有k个结点 3.二叉树，如果其叶结点为n0，而度为2的结点总数为n2，则n0=n2+1 4.有n个结点的完全二叉树的深度k为：k=[log2n]+1 5.有n个结点的完全二叉树各结点如果用顺序表存储，对任意结点i，有如下关系： 如果
二叉平衡树（C++）
wo_ai_luo_的博客
02-25 1062
平衡二叉树也叫做AVL树,AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树(Self-Balancing Binary Search Tree,简称平衡二叉树。我们怎么知道这棵二叉搜索树平不平衡呢？我们知道，二叉搜索树的搜索时间和高度是有直接关系的，但是我们按递增、递减序输入之后，高度就和n一样了，所以时间复杂度为O(log n).想要优化，就是改变这棵二叉搜索树的高度。
STL源码阅读-红黑树（RB-tree）、AVL树、AA树
飞鸟
07-27 2374
STL源码剖析看到了第五章节，源代码部分也看完了几个比较关键的
二叉树的顺序存储结构------(C语言实现)
makabaka12138的博客
04-05 2464
上图所示的二叉树用顺序存储方式存为 A B C D E 0 F ... 相当于一个一维数组啦 下面是代码实现： //定义二叉树的最大结点数 #define MAX_SIZE 255 //下标为0的位置存储根结点 typedef Element SqBinTree[MAX_SIZE]; SqBinTree tree; ...
二叉树类BinTree的声明
weixin_34256074的博客
03-27 170
#pragma once #include "stdafx.h" #include "BinTreeNode.h" #include "Stack.h" //二叉树类BinTree的声明 template <typename T> class BinTree { private: //指向根结点 BinTreeNode<T>* root...
二叉树基本操作
lzy820260594的博客
10-22 588
摘要：本文主要介绍了二叉树的基本操作的实现并且进行了测试。 SqBinaryTree.h 1 #ifndef _BINARYTREE_ 2 #define _BINARYTREE_ 3 #include<iostream> 4 using namespace std; 5 6 //首先定义二叉树结点类模板 7 template<class ElemTy...
二叉平衡树查找，插入与删除.zip
09-04
二叉平衡树是一种特殊的二叉树结构，它的左右子树高度差不超过1，这使得它在查找、插入和删除操作上的效率比普通的二叉搜索树更高。本项目以HTML+JavaScript实现二叉平衡树，提供了查找、插入和删除功能，便于理解和...
二叉平衡树提升物联网边缘计算效率.pptx
05-23
### 二叉平衡树提升物联网边缘计算效率 #### 一、二叉平衡树的基本概念及特点 二叉平衡树作为一种自平衡的二叉查找树，其核心在于始终保持左右子树的高度差不超过1，以达到高度平衡的状态。这种设计使得二叉平衡树...
二叉平衡树增强物联网数据隐私保护.pptx
最新发布
05-23
二叉平衡树作为一种高度平衡的二叉搜索树，在数据存储和检索方面有着高效的表现，尤其在处理大规模数据集时优势显著。本篇内容将重点探讨二叉平衡树的基本概念、特性以及如何通过二叉平衡树增强物联网数据隐私保护的...
二叉平衡树改进物联网数据流分析效率.pptx
05-23
### 二叉平衡树改进物联网数据流分析效率 #### 一、二叉平衡树的简介 二叉平衡树作为一种高效的数据结构，在计算机科学领域扮演着重要角色。它是一种特殊的二叉搜索树，其中任何节点的两个子树的高度差最多为1。...
二叉树功能函数 BinTree.cpp
布衣天使
10-23 1487
/////////////////////////// //    // //   主函数 index.cpp  用户菜单 // //    // ////////////////////////// #include #include"BaseFun.h" void main() { //功能菜单 do { cout  coutint kind; cin>>kind; switch(kind)
平衡二叉排序树AVL介绍
qq_40707269的博客
06-22 124
为甚么要诞生平衡二叉排序树？ 因为一般的二叉树，面对有序数组，会变得很畸形。 这种就是畸形而且诡异的东西。 平衡二叉树的核心是要平衡，一个二叉排序树如果不平衡，我们需要通过旋转的方式让它变得平衡，不然肯定不行啊同志。 一定要清楚知道二叉树的，左右高度。 左右高度差，小于2就是平衡的，大于2就不平衡了。 先进行分类一共4个分类 找到出问题那个节点的父亲节点，你的孩子影响了高度，你就要承担责任·，需要找到父亲节点。 找到出问题节点的父亲节点。然后根据父亲节点的位置，判定是什么问题类型？是rr?rl?ll
从bintree、Trie 到三叉搜索树
exception_action的专栏
01-19 1797
最近在《程序员》杂志上看到一个.net大牛写一篇《用三叉搜索树实现高效率的“自动完成”》的文章，感觉这种方法确实不错。　　对于字符串的高效处理一般都是用字典树——Trie。虽然执行也是非常快，但是用这种数据结构需要消耗非常多的内存。Trie是一种形似树的数据结构，它的每个节点都包含一个指针数组，其中每一个指针对应着字母表里的一个字母。从根节点开始，我们只要依次找到目标单词里下一个字母对应的指针
二叉树简介
qq_40635938的博客
12-25 1314
二叉树 First. 二叉树和二次树不同，二次树至少有一个结点的度为2，二叉树没有这个要求。 二次树不区分左右子树，二叉树严格区分左右子树 满二叉树： 所有的分支结点都有左右孩子结点，叶子结点在最下面一层 非空满二叉树特点：1.叶子结点在最下面一层 2.只有度为0和2的点 完全二叉树：一层一层从左往右地排，刚好没排完.。所以若是存在度为1的结点，只有一个 二叉树的性质： 非空二叉树上的叶子结...
数据结构资料（七）——树与二叉树
FFFPAG的博客
08-21 468
树的基本概念 定义 逻辑表示方法 基本术语 性质 基本运算 存储结构 二叉树的概念和性质 定义 性质 二叉树与树，森林之间的转换 二叉树的存储结构 二叉树的顺序存储结构 二叉树的链式存储结构 二叉树的基本运算及其实现 二叉树的基本运算概述 二叉树的基本运算算法实现 二叉树的遍历 概念 先序，中序和后序遍历递归算法 先序，中序和后序遍历非递归算法 层次遍历算法 二叉树的构造 线索二叉树 概念 线索化二叉树 遍历线索二叉树 哈夫曼树 概述 构造算法 哈夫曼编码 ...
二叉搜索树的插入和删除
chy89224的博客
02-13 372
typedef struct TreeNode *BinTree; typedef BinTree Position; struct TreeNode{ ElementType Data; BinTree Left; BinTree Right; }; BinTree BST; BinTree Insert(ElementType X,B
链表常见面试题-C语言实现
IT_iverson的博客
08-03 8079
前面的博客已经介绍过了实现链表的一些相关的功能，所以在这里就不对链表多加解释说明了。 对于链表相关面试题这里解释几个有特点的题： 1.对于求查找链表的中间结点，要求只能遍历一次链表？ 方式：使用两个指针，一个快指针,一个慢指针,快指针走两步慢指针走一步，这样当快指针指向结尾空指针的时候，慢指针刚好指向中间结点。 图示： 2.查找链表倒数第K个结点要求只能遍历一次链表？ 方式：同
哈夫曼树的实现
IT_iverson的博客
01-10 2710
在这里关于什么是哈夫曼树就不多说了，自己去查阅相关的资料书籍，下面来说说如何实现哈夫曼树。 首先语言描述一下实现的步骤：假设这里给出得到数组元素为5，3，1，7   1.在当前数组中找出最小的两个数各自为一个结点生成如下：
二叉排序树与二叉平衡树
03-20
二叉平衡树（Balanced Binary Tree）是一种特殊的二叉排序树，它在保持二叉排序树性质的基础上，还具有以下性质： 1. 左右子树的高度差不超过1。 2. 左右子树也分别为二叉平衡树。 通过保持平衡性，二叉平衡树可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值