C++ 自平衡二叉搜索树的实现

最新推荐文章于 2023-08-27 15:04:09 发布
最新推荐文章于 2023-08-27 15:04:09 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 数据结构算法 逻辑算法 C/C++/C# 文章标签： c++ insert null delete class tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xgx198831/article/details/7335179
版权

 C++ 自平衡二叉搜索树的实现

头文件

// AVLTree.h  for class avltree

#ifndef AVLTREE_H__________
#define AVLTREE_H__________
//#include <AFX.H>

typedef int BOOL;
#define NULL 0
#define TRUE 1
#define FALSE 0
typedef int ElemType;
struct TreeNode    // AVL树数据结构
{
	ElemType data;
	int color;
	struct TreeNode *parent;
	struct TreeNode *left;
	struct TreeNode *right;

	TreeNode(ElemType val);
	int GetLeftHight();
	int GetRightHight();
	int GetDiffHight();
	void GetNodes(TreeNode *pNode, int h);
};

// 栈类 用于存放查找结点的路径，便于回溯找到最小不平衡结点
class CStack
{
public:
	CStack(int nMaxSize = 100);
	~CStack();

	BOOL Pop(TreeNode *& node);
	BOOL Push(TreeNode * node);
	BOOL Top(TreeNode *&node);
	BOOL GetNext(TreeNode* &node);
	int Size()const{return m_nCount; }

private:
	int m_nCount;
	int m_nCurPos;
	int m_nMaxSize;
	TreeNode* *m_arrNode;  // 存放数据结点
};

// AVL树类 自平衡二叉搜索树
class CAVLTree
{
public:
	CAVLTree();
	~CAVLTree();

	int Insert(ElemType val);
	int Remove(ElemType val);
	TreeNode* Find(const ElemType &val);
	void DoBalance(TreeNode *& pCurNode, TreeNode *& pParent, int nLRFlag);
	void PrintTree();
	void EmptyTree();
	int GetSize()const { return m_nSize; }

private:
	void GetNoBalanceNode(CStack &st, TreeNode *& pCurNode, TreeNode *& pParent, int &nLRFlag);
	BOOL LL_Rotate(TreeNode *& pCurNode, TreeNode *& pParentNode, const int &nLRFlag);
	BOOL LR_Rotate(TreeNode *& pCurNode, TreeNode *& pParentNode, const int &nLRFlag);
	BOOL RR_Rotate(TreeNode *& pCurNode, TreeNode *& pParentNode, const int &nLRFlag);
	BOOL RL_Rotate(TreeNode *& pCurNode, TreeNode *& pParentNode, const int &nLRFlag);
	void PrintTree(TreeNode *& pNode);
	void GetNodes(CStack &st, TreeNode *pNode);
	void SwapNodes(TreeNode *&pNode1, TreeNode *&pNode2);

private:
	TreeNode *m_root;
	int m_nSize;
};

#endif


 

实现文件

// AVLTree.cpp  for implete class CAVLTree
#include <iostream>
#include "AVLTree.h"
#include <Windows.h>
using namespace std;
///

/// constructure functions

 struct TreeNode implete
//
TreeNode::TreeNode( ElemType val )  // 构造函数
{
	data = val;
	left = NULL;
	right = NULL;
	parent = NULL;
	color = 0;
}
int nHight = 0;

int TreeNode::GetLeftHight()
{ // 获取结点左子树高度
	nHight = 0;
	GetNodes(this->left, 0);
	return nHight;
}

int TreeNode::GetRightHight()
{  // 获取结点右子树高度
	nHight = 0;
	GetNodes(this->right, 0);
	return nHight;
}

int TreeNode::GetDiffHight()
{  // 获取结点左右子树高度的差，当放回值的绝对值大于1时，该结点为不平衡结点，需要进行结点的自平衡处理
	return (GetLeftHight() - GetRightHight());
}

void TreeNode::GetNodes(TreeNode *pNode, int h)
{ // 递归直到搜索到叶子结点，取最大的值为某结点到叶子结点的高度
	if (pNode == NULL)
	{
		nHight = (nHight > h)? nHight:h;
		return;
	}
	h++;
	GetNodes(pNode->left, h);
	GetNodes(pNode->right, h);
}

/ class CStack implete
/

CStack::CStack( int nMaxSize )  // 构造函数
{
	m_nCount = 0;
	m_nMaxSize = nMaxSize;
	m_arrNode = new TreeNode *[m_nMaxSize];
}

CStack::~CStack()  // 析构函数
{
	delete []m_arrNode;
}

BOOL CStack::Pop( TreeNode *& node )  // 出栈
{
	if (m_nCount <= 0)
		return FALSE;
	m_nCount--;
	node = m_arrNode[m_nCount];
	return TRUE;
}

BOOL CStack::Push( TreeNode * node )  // 进栈
{
	if(m_nCount < m_nMaxSize-1)
	{
		m_arrNode[m_nCount] = node;
		m_nCount++;
		return TRUE;
	}
	return FALSE;
}

BOOL CStack::Top( TreeNode *&node )  // 获取栈顶值
{
	if (m_nCount > 0)
	{
		node = m_arrNode[m_nCount-1];
		m_nCurPos = m_nCount - 1;
		return TRUE;
	}
	return FALSE;
}

BOOL CStack::GetNext( TreeNode* &node ) // 第一次返回的值为栈顶的下一数值
{
	if (m_nCurPos-1 < m_nCount-1 && m_nCurPos-1 >= 0)
	{
		m_nCurPos--;
		node = m_arrNode[m_nCurPos];
		return TRUE;
	}
	return FALSE;
}


/ class CAVLTree implete
//
CAVLTree::CAVLTree()  // 构造函数
{
	m_root = NULL;
	m_nSize = 0;
}

CAVLTree::~CAVLTree()
{
	EmptyTree();  //释放该树结构所有结点
}

int CAVLTree::Insert( ElemType val )  // 插入树结点
{
	CStack stNodes(100000);
	TreeNode *pNewNode = new TreeNode(val);
	TreeNode *pNode = m_root;
	TreeNode *preNode = NULL;
	int nFlag;  // 0--left 1--right
	if (m_root == NULL)
	{  // 该树为空
		m_root = pNewNode;
		cout<< "Insert root node: " << pNewNode->data <<" succeed." <<endl;
	//	Sleep(500);
		m_nSize++;
		return 1;
	}
	while(1)
	{   // 查找要插入的位置
		preNode = pNode;
		if (val < pNode->data)
		{
			stNodes.Push(pNode);
			pNode = pNode->left;
			nFlag = 0;
		}
		else if (val > pNode->data)
		{
			stNodes.Push(pNode);
			pNode = pNode->right;
			nFlag = 1;
		}
		else 
		{
			delete pNewNode;
			return 0;
		}

		if (!pNode) //页子结点
		{
			if (nFlag == 0)
			{
				preNode->left = pNewNode;
			}
			else
				preNode->right = pNewNode;
	//		Sleep(500);
			break;
		}
	}
	TreeNode *pNBLNode = NULL;
	TreeNode *pNBLParent = NULL;
	nFlag = 0;
	GetNoBalanceNode(stNodes, pNBLNode, pNBLParent, nFlag);
	if (pNBLNode)
	{
		DoBalance(pNBLNode, pNBLParent, nFlag);
	}
	m_nSize++;
	cout<< "Insert "<< m_nSize <<" node: " << pNewNode->data <<" succeed." <<endl; 
	return 1;
}

int CAVLTree::Remove( ElemType val )  // 删除某一结点
{
	if (!m_root) return 0;
	CStack stNodes(100000);  // 记录查找的路径结点
	TreeNode *pNode = m_root;
	TreeNode *pPreNode = m_root;
	int nLRFlag;
	while(pNode)
	{
		if (val < pNode->data)
		{
			stNodes.Push(pNode);
			if (pNode->left)
			{
				pPreNode = pNode;
			}
			pNode = pNode->left;
			nLRFlag = 0;
		}
		else if (val > pNode->data)
		{
			stNodes.Push(pNode);
			if (pNode->right)
			{
				pPreNode = pNode;
			}
			pNode = pNode->right;
			nLRFlag = 1;
		}
		else break;	
	}
	if (!pNode)   //没找到要删除的结点
		return 0;
	if (!stNodes.Top(pPreNode))
	{ // tree has only one root node.
		pPreNode = NULL;
		if (pNode->left == NULL && pNode->right == NULL)
		{
			delete pNode;
			m_root = NULL;
			m_nSize--;
			return 1;
		}
	}
	if (pNode->left)  //pNode为要删除的结点
	{ // 寻找该结点的左子树中最大的结点与之交换位置
		TreeNode *pNodeDel = pNode->left;
		TreeNode *pPre = pNode;
		stNodes.Push(pPre);
		while(pNodeDel->right)
		{
			pPre = pNodeDel;
			stNodes.Push(pPre);
			pNodeDel = pNodeDel->right;
		}
		SwapNodes(pNode, pNodeDel);  // 将要删除的结点与符合要求的叶子结点交换，然后删除该叶子结点
		if (pPre->left == pNodeDel)// pNode 左边只有一个叶子结点
		{
			pPre->left = pNodeDel->left;
		}
		else
			pPre->right = pNodeDel->left;

		delete pNodeDel;  // 释放叶子结点
	}
	else if (pNode->right)
	{ // 寻找该结点的右子树中最小的结点与之交换位置
		TreeNode *pNodeDel = pNode->right;
		TreeNode *pPre = pNode;
		stNodes.Push(pPre);
		while(pNodeDel->left)
		{
			pPre = pNodeDel;
			stNodes.Push(pPre);
			pNodeDel = pNodeDel->left;
		}
		SwapNodes(pNode, pNodeDel);
		pPre->right = pNodeDel->left;

		delete pNodeDel;
	}
	else  // 该结点为叶子结点
	{
		delete pNode;
		if (nLRFlag == 0)
		{
			pPreNode->left = NULL;
		}
		else
			pPreNode->right = NULL;
	}
	cout << "Remove node: " << val << " succeeded!\n";
//	Sleep(500);
	/// 检查不平衡结点
	TreeNode *pNBLNode = NULL;
	TreeNode *pPreNBLNode = NULL;
	nLRFlag = 0;
	GetNoBalanceNode(stNodes, pNBLNode, pPreNBLNode, nLRFlag);
	if (pNBLNode)
	{
		DoBalance(pNBLNode, pPreNBLNode, nLRFlag);
	}
	m_nSize--;
	return 1;	
}

TreeNode* CAVLTree::Find( const ElemType &val )  // 查找某一结点
{
	if (m_root == NULL) return NULL;
	TreeNode *pNode = m_root;
	while (pNode)
	{
		if (pNode->data < val)
		{
			pNode = pNode->right;
		}
		else if (pNode->data > val)
		{
			pNode = pNode->left;
		}
		else
		{
			cout << "Find node: " << val << " succeeded!\n";
			return pNode;
		}
	}
	return NULL;	
}

// 获取不平衡的结点的信息
void CAVLTree::GetNoBalanceNode( CStack &st, TreeNode *& pCurNode, TreeNode *& pParent, int &nLRFlag )
{
	TreeNode *pNode;
	if (!st.Top(pNode))	return ;
	while(1)
	{
		int nDiff = pNode->GetDiffHight();
		if (nDiff > 1 || nDiff < -1)
		{
			pCurNode = pNode;
			if (st.GetNext(pParent))
			{
				if (pParent->left == pCurNode)
				{
					nLRFlag = 0;  // left child
				}
				else /*if (pParent->right == pCurNode)*/
				{
					nLRFlag = 1;  // right child
				}
				return ;
			}
		}
		if (!st.GetNext(pNode))
		{
			return ;
		}
	}
}

// 自平衡处理函数
void CAVLTree::DoBalance( TreeNode *& pCurNode, TreeNode *& pParent, int nLRFlag )
{
	cout << "Call DoBalance() succeeded!\n";
	if (pCurNode->GetLeftHight() > pCurNode->GetRightHight())
	{
		if (pCurNode->left->GetLeftHight() > pCurNode->left->GetRightHight())
		{
			LL_Rotate(pCurNode, pParent, nLRFlag);  // LR型 平衡处理
		}
		else
			LR_Rotate(pCurNode, pParent, nLRFlag);  // LL型 平衡处理
	}
	else
	{
		if (pCurNode->right->GetLeftHight() > pCurNode->right->GetRightHight())
		{
			RL_Rotate(pCurNode, pParent, nLRFlag);  // RL型 平衡处理
		}
		else
			RR_Rotate(pCurNode, pParent, nLRFlag);  // RR型 平衡处理
	}
}

BOOL CAVLTree::LL_Rotate( TreeNode *& pCurNode, TreeNode *& pParentNode, const int &nLRFlag )
{
	cout << "Call LL_Rotate() succeeded!\n";
	TreeNode *pTempRoot = pCurNode->left;
	TreeNode *pTempRootR = pTempRoot->right;
	pTempRoot->right = pCurNode;
	pCurNode->left = pTempRootR;
	if (pParentNode)
	{
		if (nLRFlag == 0)
		{
			pParentNode->left = pTempRoot;
		}
		else
			pParentNode->right = pTempRoot;
	}
	else  // root
		m_root = pTempRoot;
	
	return TRUE;
}

BOOL CAVLTree::LR_Rotate( TreeNode *& pCurNode, TreeNode *& pParentNode, const int &nLRFlag )
{
	cout << "Call LR_Rotate() run succeeded!\n";
	TreeNode *pNodeA = pCurNode->left;
	TreeNode *pNodeB = pNodeA->right;
	TreeNode *pPreB = pNodeA;
	TreeNode *pTempRoot = NULL;
	while(pNodeB->right)
	{
		pPreB = pNodeB;
		pNodeB = pNodeB->right;
	}
	pTempRoot = pNodeB;
	if (pTempRoot == NULL)   // pNodeA 的右子树为空
	{
		pTempRoot = pNodeA;
		pTempRoot->right = pCurNode;
		pCurNode->left = NULL;
	}
	else
	{
		pPreB->right = pTempRoot->left;
		pTempRoot->left = pNodeA;
		pTempRoot->right = pCurNode;
		pCurNode->left = NULL;
	}
	if (pParentNode)
	{
		if (nLRFlag == 0)
		{
			pParentNode->left = pTempRoot;
		}
		else
			pParentNode->right = pTempRoot;
	}
	else  // root
		m_root = pTempRoot;

	
	return TRUE;
}

BOOL CAVLTree::RR_Rotate( TreeNode *& pCurNode, TreeNode *& pParentNode, const int &nLRFlag )
{
	cout << "Call RR_Rotate() succeeded!\n";
	TreeNode *pTempRoot = pCurNode->right;
	TreeNode *pTempRootL = pTempRoot->left;
	pTempRoot->left = pCurNode;
	pCurNode->right = pTempRootL;
	if (pParentNode)
	{
		if (nLRFlag == 0)
		{
			pParentNode->left = pTempRoot;
		}
		else
			pParentNode->right = pTempRoot;
	}
	else  // root
		m_root = pTempRoot;
	
	return TRUE;
}

BOOL CAVLTree::RL_Rotate( TreeNode *& pCurNode, TreeNode *& pParentNode, const int &nLRFlag )
{
	cout << "Call RL_Rotate() run succeeded!\n";
	TreeNode *pNodeA = pCurNode->right;
	TreeNode *pNodeB = pNodeA->left;
	TreeNode *pPreB = pNodeA;
	while(pNodeB->left)
	{
		pPreB = pNodeB;
		pNodeB = pPreB->left;
	}
	TreeNode *pTempRoot = pNodeB;
	if (pTempRoot == NULL)
	{
		pTempRoot = pNodeA;
		pCurNode->right = NULL;
		pTempRoot->left = pCurNode;
	}
	else
	{
		pTempRoot->left = pCurNode;
		pCurNode->right = NULL;
		pPreB->left = pTempRoot->right;
		pTempRoot->right = pNodeA;
	}

	if (pParentNode)
	{
		if (nLRFlag == 0)
		{
			pParentNode->left = pTempRoot;
		}
		else
			pParentNode->right = pTempRoot;
	}
	else  // root
		m_root = pTempRoot;
	
	
	return TRUE;
}

void CAVLTree::PrintTree()   // 打印树结点
{
	if (!m_root)
	{
		cout << "The tree is empty!\n";
		return ;
	}
	PrintTree(m_root);  // 调用递归遍历结点函数
	cout << endl;
}

void CAVLTree::PrintTree( TreeNode *& pNode )
{
	if (pNode)
	{
		cout << pNode->data << "  ";
		PrintTree(pNode->left);
		PrintTree(pNode->right);
	}
}

void CAVLTree::EmptyTree()  // 清空结点，释放结点空间
{
	if (!m_root)
	{
		return;
	}
	CStack stNodes(10000);
	GetNodes(stNodes, m_root);
	TreeNode *pTemp;
	if (stNodes.Pop(pTemp))
	{
		delete pTemp;
	}
	m_root = NULL;
	cout << "Emptied the tree succeeded!\n";
}

void CAVLTree::GetNodes( CStack &st, TreeNode *pNode )
{
	if (pNode)
	{
		GetNodes(st, pNode->left);
		GetNodes(st, pNode->right);
	}
}

void CAVLTree::SwapNodes( TreeNode *&pNode1, TreeNode *&pNode2 )  // 交换两个结点
{
	ElemType val = pNode1->data;
	pNode1->data = pNode2->data;
	pNode2->data = val;
}


 

测试文件

/// test.cpp for test the class CAVLTree
#include <iostream>
#include "AVLTree.h"
#include <ctime>
using namespace std;

void LL_Test();
void RR_Test();
void LR_Test();
void RL_Test();
void time_Test();
void main()
{
	time_Test();
// 	LL_Test();
// 	RR_Test();
//	LR_Test();
//	RL_Test();
	return;
}

void time_Test()
{
	cout << "time_Test Function.\n";
	CAVLTree tree;
	clock_t t_insert, t_print, t_find;  // 分别记录插入数据时间和打印数据时间
	int nArrNodes[30000];
	srand((unsigned)time(NULL));
//	srand(0);
	t_insert = clock();
	for (int i = 0; i < 30000; i++)
	{
		nArrNodes[i] = rand();
		while (1)
		{
			if (tree.Find(nArrNodes[i]) == NULL)
			{
				tree.Insert(nArrNodes[i]);
				break;
			}
			else
				nArrNodes[i] = rand();
		}	
	}
	t_insert = clock() - t_insert;
	t_print = clock();
	tree.PrintTree();
	t_print = clock() - t_print;
	t_find = clock();
	tree.Find(32725);
	t_find = clock() - t_find;
	cout << "The tree nodes count is: " << tree.GetSize() << endl;
	cout << "Insert data need time: " << t_insert << "ms." << endl;
	cout << "Print data need time: " << t_print << "ms." << endl;
	cout << "Find one data need time: " << t_find << "ms." << endl;
}

void LL_Test()
{
	cout << "/LL_Test" << endl;
	CAVLTree tree;
	tree.Insert(9);
	tree.Insert(5);
	tree.Insert(11);
	tree.Insert(6);
	tree.Insert(15);
	tree.Insert(4);
	tree.Insert(3);
	tree.PrintTree();
	tree.Remove(9);
	tree.PrintTree();
	cout << endl;
	return;
}

void RR_Test()
{
	cout << "//RR_Test" << endl;
	CAVLTree tree;
	tree.Insert(4);
	tree.Insert(2);
	tree.Insert(6);
	tree.Insert(5);
	tree.Insert(9);
	tree.Insert(11);
	tree.PrintTree();
	cout << endl;
	return;
}

void LR_Test()
{
	cout << "LR_Test" << endl;
	CAVLTree tree;
	tree.Insert(9);
	tree.Insert(4);
	tree.Insert(11);
	tree.Insert(2);
	tree.Insert(6);
	tree.Insert(5);
	tree.PrintTree();
	tree.Remove(6);
	tree.PrintTree();
	cout << endl;
	return;
}

void RL_Test()
{
	cout << "//RL_Test" << endl;
	CAVLTree tree;
	tree.Insert(4);
	tree.Insert(2);
	tree.Insert(9);
	tree.Insert(6);
	tree.Insert(11);
	tree.Insert(5);
	tree.PrintTree();
	tree.Insert(7);
	tree.Insert(8);
	tree.PrintTree();
	tree.Remove(6);
	tree.PrintTree();
	tree.Remove(11);
	tree.PrintTree();
	tree.Remove(7);
	tree.PrintTree();
	tree.Remove(8);
	tree.PrintTree();
	tree.Remove(9);
	tree.PrintTree();
	tree.Remove(4);
	tree.PrintTree();
	tree.Remove(2);
	tree.PrintTree();
	tree.Remove(5);
	tree.PrintTree();
	cout << endl;
	return;
}


 

夜空划过的流星
关注
专栏目录
C++AVL树(自平衡二叉查找树)(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-10 296
@TOC) node结构体定义 typedef struct node { int data; int height; struct node *left; struct node *right; } node; 实现了以下几个接口 node *createNode(int data); // Create and return a new Node int height(node *root); // Returns height of tree int g
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2759
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
平衡二叉树（纯C++实现）
03-04
包含AVL树的创建，删除，查找等等功能，我使用的是VS2010的编译器，可能用版本低的编译器无法打开
AVL平衡树(二叉搜索树 c++实现)
WinForBest
10-30 618
AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 一棵AVL树有如下必要条件： 条件一：它必须是二叉查找树。 条件二：每个节点的左子树和右子树的高度差至多为1。
平衡二叉树c++实现
09-26
AVL的c++非递归实现 经测试可直接使用 由于在网上找的程序均有些小bug（可以用此程序中的测试代码测试，较少有别的代码能直接通过），所以自己写了一个。
《大话数据结构》C++实现二叉平衡树的建立
人强小的博客
08-07 380
平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树，同时，平衡二叉树必定是二叉排序树。 高度差可以用平衡因子bf来定义，我们用左子树的高度减去右子树的高度来表示bf，即-1<|bf|<1。 引入平衡二叉树...
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
二叉树是一种特殊的树结构，每个节点最多只有两个子节点，通常分为左子节点和右子节点。...理解并掌握二叉搜索树的原理和操作是提升算法能力的关键，而自平衡二叉搜索树则进一步提高了在大规模数据处理中的效率。
二叉平衡树（C++）
wo_ai_luo_的博客
02-25 1097
平衡二叉树也叫做AVL树,AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树(Self-Balancing Binary Search Tree,简称平衡二叉树。我们怎么知道这棵二叉搜索树平不平衡呢？我们知道，二叉搜索树的搜索时间和高度是有直接关系的，但是我们按递增、递减序输入之后，高度就和n一样了，所以时间复杂度为O(log n).想要优化，就是改变这棵二叉搜索树的高度。
C++实现完美二叉搜索树算法
为了维持树的平衡，通常会采用自平衡二叉搜索树的数据结构，如AVL树或红黑树。 C++代码实现的细节可能包括： - 定义二叉搜索树节点的数据结构，包括键值和左右指针。 - 实现插入节点的函数，它能够根据键值将新...
shujujiegou__c++.rar_kruskal_二叉搜索树
09-21
AVL树是一种自平衡的二叉搜索树，它的每个节点的左右子树高度差不超过1，这保证了任何操作（如插入、删除）后的树仍然保持平衡，从而保证了操作的时间复杂度为O(logn)。AVL树的平衡调整包括单旋和双旋操作，这些可能...
平衡二叉排序树的算法实现
09-18
平衡二叉排序树的算法实现
平衡二叉树的c++实现
qq_41646522的博客
03-14 1092
插入节点： (为什么可以将其移动到另一方作为子树，考虑其左小于父节点以及右大于父节点的性质，即可理解可移动) 二叉树删除节点： 1.若删除节点为叶子节点==》直接删除 2.欲删除节点只有一个子树，删除该head,把子树移到head位置 3.欲删除节点有双子树，（右子树的最左节点为大于且最接近欲删除节点的值）找到该最接近节点node将其与欲删除节点交换，问题转换为{ 删除右子树中，值为node->key的节点（该节点为叶子节点或只有右子树的节点）<即转换为1，2情况> } AVLTree.
C++ 二叉平衡树
m0_51262652的博客
12-24 875
二叉平衡树的插入操作 (C++ ) #pragma once #if 1 using namespace std; #include<assert.h> template<class K,class V> // 模板声明; struct AVLTreeNode { AVLTreeNode<K, V>* _left;// 左子树 AVLTreeNode<K, V>* _right;// 右子树 AVLTreeNode<K, V>* _par
C++实现树 - 07 平衡二叉树
Newin2020的博客
05-29 1700
写在前面： 这一讲我们来讲讲目前为止难度最大的一种树，当然后面要有 B 树、B+ 树和红黑树等着我们。同样，我会将详细的代码附到详解的最后。 平衡二叉树的定义 我们之前学了二叉排序树，但是二叉排序树存在一个致命的问题，如果我每次插入的值都比上一次插入的大，那它就会形成一个斜树，这对我们的查找删除等功能影响很大。 我们经过平衡操作就可以得到这样一颗树（具体如何操作下面会讲到）： 所以平衡二叉树就由此诞生了，平衡二叉树定义其可以为空树，但是每个结点的左右子树的高度只差不能超过 1 ，所以就引入了一个新概.
平衡二叉树（C/C++）
Ivan_47的博客
12-28 423
描述： 平衡二叉树是二叉搜索树的改进，本文基于你已了解二叉搜索树为前提，不了解的朋友请看这里： https://blog.csdn.net/Ivan_47/article/details/111831396 当我们使用二叉搜索树时，若我们按递增或递减的顺序插入结点，那么每一次的新结点都会插入在左子树或右子树，这样一来二叉树便退化为了链表，那么搜索的效率就会降低。 为提升二叉排序树的平均效率，可将其升级为平衡二叉树，其特点是：所有根结点的左子树和右子树深度差不超过1。其中左右子树的深度差也称为平衡因子。每插入
C++高级数据结构算法#自平衡的二叉搜索树(AVL树)
Nonpc的博客
06-16 2114
文章目录前言自平衡的二叉搜索树(AVL树)AVL树的结构定义AVL树的旋转AVL树失衡的4种情况 :失衡的处理方法左旋操作右旋操作左平衡操作右平衡操作AVL树插入操作AVL树的删除操作判断一颗二叉搜索树是不是平衡树判断一颗二叉树是否是平衡二叉搜索树 前言 二叉搜索树是基于折半查找思想设计的一种数据结构 . 通过分析 , 可知二叉搜索树的确可以在很大程度上提高搜索的效率 . 然而 , 尽管当二叉搜索...
平衡二叉树（AVL树）C++
qq_73881574的博客
08-27 866
让待删除结点左子树当中key值最大的结点，或待删除结点右子树当中值最小的结点代替待删除结点被删除（代码中以后者为例），然后再将待删除结点的key值以及value值都改为代替其被删除的结点的值即可。1.当parent的平衡因子为-2，parent的左孩子的平衡因子为-1时，进行右单旋。2.当parent的平衡因子为-2，parent的左孩子的平衡因子为1时，进行左右双旋。4.当parent的平衡因子为2，parent的右孩子的平衡因子为-1时，进行右左双旋。与二叉搜索树相比，多了更新平衡因子这个步骤。
平衡二叉树算法实现C++
weixin_51626421的博客
06-29 2498
数据结构课程设计之平衡二叉树算法实现
【C++研发面试笔记】10. 基本数据结构-平衡二叉搜索树AVL
tostq的专栏
10-02 1239
【C++研发面试笔记】10. 基本数据结构-平衡二叉搜索树AVL10.1 AVL的定义定义：平衡二叉树或为空树,或为如下性质的二叉排序树: （1）左右子树深度之差的绝对值不超过1; （2）左右子树仍然为平衡二叉树. 平衡因子BF=左子树深度－右子树深度. 平衡二叉树每个结点的平衡因子只能是1，0，-1。若其绝对值超过1，则该二叉排序树就是不平衡的。10.2 AVL的实现10.2.1 结构10
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值