avl树实现

于 2011-12-02 00:16:07 发布
阅读量1.4k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
文章标签： tree class null string exception insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenloug/article/details/7032874
本文详细介绍了一种自平衡二叉查找树——AVL树的实现原理与具体应用。包括异常处理、节点定义、插入删除操作及旋转调整等内容，并通过一个完整的C++实现示例进行说明。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//=================avl 的异常处理类=======================
//============== avl_tree_exception.h=====================
#ifndef AVL_TREE_EXCEPTION_H_
#define AVL_TREE_EXCEPTION_H_
#include<stdexcept>
#include<string>
class ATException: public std::logic_error
{
	public:
		ATException(const std::string &message="")
			:std::logic_error(message.c_str())
		{}
};
#endif


 

//====================avl_tree_item.h=====================
//===========存放节点中数据，包含两项关键字和值=========
#ifndef AVL_TREE_ITEM_H_
#define AVL_TREE_ITEM_H_
template<class ValT,class KeyT>
class Item
{
	private:
		ValT val;
		KeyT key;
	public:
		Item()
		{}
		Item(ValT &_val,KeyT &_key)
			:val(_val),key(_key)
		{
		}
		void set(ValT _val,KeyT _key)
		{
			val=_val;
			key=_key;
		}
		KeyT getKey()const
		{
			return key;
		}
		ValT getVal()const
		{
			return val;
		}
};
#endif


 

//========================avl_tree_node.h========================
//===================avl 树的节点，包含有========================
//===========左右孩子的指针 leftPtr and rightPtr=================
//=======bal 标识 该节点左右子树的相对高度LH  , EH or RH=========
#ifndef AVL_TREE_NODE_H_
#define AVL_TREE_NODE_H_
//mark the state of the current node
//LH----left subtree is higher than right subtree 1 node;		
//EH----left subtree is equal to right subtree;
//RH----left subtree is shorter than right subtree 1 node;
#define LH +1
#define EH 0
#define RH -1
template<class ItemT,class KeyT> class AvlTree;
template<class ItemT,class KeyT>
class Node
{
	private:
		
		ItemT item;
		Node *leftPtr,*rightPtr;
		int bal;
		Node(ItemT &_item,Node *_leftPtr,Node *_rightPtr)
			:item(_item),leftPtr(_leftPtr),rightPtr(_rightPtr)
		{
			bal=EH;
		}
		friend class AvlTree<ItemT,KeyT>;
};
#endif


 

//=======================avl_tree.h======================
//======================定义avl的类======================
#ifndef AVL_TREE_H_
#define AVL_TREE_H_
#include"avl_tree_exception.h"
#include"avl_tree_node.h"
template<class ItemT,class KeyT>
class AvlTree
{
	public:
		AvlTree();
		AvlTree(AvlTree &_tree);
		~AvlTree();

		void insert(ItemT &_item)throw(ATException);
		void remove(KeyT &_key)throw(ATException);
		void retrieve(KeyT &_key,ItemT &_item)throw(ATException);
		void traverse(void (*visit)(ItemT _item));
		bool empty()const;
	protected:
		void insertNode(Node<ItemT,KeyT> *&treePtr,ItemT & newitem,bool &taller)throw(ATException);

		void removeNode(Node<ItemT,KeyT> *&treePtr,KeyT &_key,bool &shorter)throw(ATException);

		//当平衡的avl树经过处理（insert or delete）后，失去原有的平衡，则调用
		//leftBalance 或者 rightBalance 函数处理，重新得到平衡
		void leftBalance(Node<ItemT,KeyT> *&treePtr,bool &state);
		void rightBalance(Node<ItemT,KeyT> *&treePtr,bool &state);

	
		void rotateLeft(Node<ItemT,KeyT> *&treePtr);
		void rotateRight(Node<ItemT,KeyT> *&treePtr);

		void retrieveNode(Node<ItemT,KeyT> *&treePtr,KeyT &_key,ItemT &_item)throw(ATException);
		
		void traverseNode(Node<ItemT,KeyT> *&treePtr,void (*visit)(ItemT _item));

		void copy(Node<ItemT,KeyT> *&treePtr,Node<ItemT,KeyT> *&oldPtr)throw(ATException);

		void destroy(Node<ItemT,KeyT> *&treePtr);

	private:
		Node<ItemT,KeyT> *root;
};
#endif


//=====================avl_tree.cpp======================
//===============avl_tree.h 的实现文件===================
#include<cstddef>
#include"avl_tree.h"
template<class ItemT,class KeyT>
AvlTree<ItemT,KeyT>::AvlTree()
{
	root=NULL;
}

template<class ItemT,class KeyT>
AvlTree<ItemT,KeyT>::AvlTree(AvlTree<ItemT,KeyT>& _tree)
{
	copy(root,_tree.root);
}

template<class ItemT,class KeyT>
AvlTree<ItemT,KeyT>::~AvlTree()
{
	destroy(root);
}
template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::insert(ItemT &_item)
	throw(ATException)
{
	bool taller=true;
	try{
		insertNode(root,_item,taller);
	}catch(ATException & e)
	{
		throw;
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::remove(KeyT &_key)
	throw(ATException)
{
	bool shorter=true;
	try{
		removeNode(root,_key,shorter);
	}catch(ATException &e)
	{
		throw;
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::retrieve(KeyT &_key,ItemT &_item)
	throw(ATException)
{
	try{
		retrieveNode(root,_key,_item);
	}catch(ATException &e)
	{
		throw;
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::traverse(void (*visit)(ItemT _item))
{
	traverseNode(root,visit);
}

template<class ItemT,class KeyT>
bool AvlTree<ItemT,KeyT>::empty()const
{
	return root==NULL;
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::insertNode(Node<ItemT,KeyT> *&treePtr,ItemT &newitem,bool &taller)
	throw(ATException)
{
	if(treePtr==NULL)
	{
		treePtr=new Node<ItemT,KeyT>(newitem,NULL,NULL);
		if(treePtr==NULL)
			throw ATException("allocate memory faild !");
		taller=true;
	}
	else if(newitem.getKey()<treePtr->item.getKey())
	{
		insertNode(treePtr->leftPtr,newitem,taller);
		if(taller)
		{
			switch(treePtr->bal)
			{
				case LH:leftBalance(treePtr,taller);
			            taller=false;
						break;
				case EH:treePtr->bal=LH;
						break;
				case RH:treePtr->bal=EH;
					    taller=false;
						break;
			}
		}
	}
	else
	{
		insertNode(treePtr->rightPtr,newitem,taller);
		if(taller)
		{
			switch(treePtr->bal)
			{
				case LH:treePtr->bal=EH;
						taller=false;
						break;
				case EH:treePtr->bal=RH;
						break;
				case RH:rightBalance(treePtr,taller);
						taller=false;
						break;
			}
		}
	} 
}

template<class ItemT ,class KeyT>
void AvlTree<ItemT,KeyT>::removeNode(Node<ItemT,KeyT>*&treePtr,KeyT &_key,bool &shorter)
	throw(ATException)
{
	if(treePtr==NULL)
		throw ATException("the key item not exist !");
	else if(_key<treePtr->item.getKey())
	{
		removeNode(treePtr->leftPtr,_key,shorter);
		if(shorter)
		{
			switch(treePtr->bal)
			{
				case LH:treePtr->bal=EH;
						break;
				case EH:treePtr->bal=RH;
						shorter=false;
						break;
				case RH:rightBalance(treePtr,shorter);
						break;
			}
		}
	}
	else if(_key>treePtr->item.getKey())
	{
		removeNode(treePtr->rightPtr,_key,shorter);
		if(shorter)
		{
			switch(treePtr->bal)
			{
				case LH:leftBalance(treePtr,shorter);
						break;
				case EH:treePtr->bal=LH;
						shorter=false;
						break;
				case RH:treePtr->bal=EH;
						break;
			}
		}
	}
	else
		//the item who's key word equal to _key exist
	{
		Node<ItemT,KeyT> *temp;
		if(treePtr->leftPtr==NULL)
			//the node pointer treePtr only has a right subtree 
			//  or is a leaf
		{
			temp=treePtr->rightPtr;
			treePtr->rightPtr=NULL;
			delete treePtr;
			treePtr=temp;
			shorter=true;
		}
		else if(treePtr->rightPtr==NULL)
			//the node pointer treePtr only has a left subtree
			//   or is a leaf
		{
			temp=treePtr->leftPtr;
			treePtr->leftPtr=NULL;
			delete treePtr;
			treePtr=temp;
			shorter=true;
		}
		else
			// the node pointer treePtr has both left subtree and
			//    right subtree 
		{
			temp=treePtr->rightPtr;
			while(temp->leftPtr!=NULL)
				temp=temp->leftPtr;
			treePtr->item=temp->item;
			removeNode(treePtr->rightPtr,temp->item.getKey(),shorter);
			if(shorter)
			{
				switch(treePtr->bal)
				{
					case LH:leftBalance(treePtr,shorter);
							break;
					case EH:treePtr->bal=LH;
							shorter=false;
							break;
					case RH:treePtr->bal=EH;
							break;
				}
			}
		}
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::leftBalance(Node<ItemT,KeyT> *&treePtr,bool &shorter)
{
	Node<ItemT,KeyT> *leftTree=treePtr->leftPtr;
	Node<ItemT,KeyT> *rightTree=leftTree->rightPtr;
	switch(leftTree->bal)
	{
		case LH:treePtr->bal=EH;
				leftTree->bal=EH;
				rotateRight(treePtr);
				break;
		case EH:treePtr->bal=LH;
				leftTree->bal=RH;
				rotateRight(treePtr);
				shorter=false;
				break;
		case RH:
			{
				switch(rightTree->bal)
				{
			    	case LH:treePtr->bal=RH;
							leftTree->bal=EH;
							break;
					case EH:treePtr->bal=EH;
							leftTree->bal=EH;
							break;
					case RH:treePtr->bal=EH;
							leftTree->bal=LH;
							break;
				}
			    rightTree->bal=EH;
				rotateLeft(leftTree);
				rotateRight(treePtr);
				break;
			}
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::rightBalance(Node<ItemT,KeyT>*&treePtr,bool &shorter)
{
	Node<ItemT,KeyT> *rightTree=treePtr->rightPtr;
	Node<ItemT,KeyT> *leftTree=rightTree->leftPtr;
	switch(rightTree->bal)
	{
		case LH:
			{
				switch(leftTree->bal)
				{
					case LH:treePtr->bal=EH;
							rightTree->bal=RH;
							break;
					case EH:treePtr->bal=EH;
							rightTree->bal=EH;
							break;
					case RH:treePtr->bal=LH;
							rightTree->bal=EH;
				}
				leftTree->bal=EH;
				rotateRight(rightTree);
				rotateLeft(treePtr);
				break;
			}
		case EH:treePtr->bal=RH;
				rightTree->bal=LH;
				rotateLeft(treePtr);
				shorter=false;
				break;
		case RH:treePtr->bal=EH;
				rightTree->bal=EH;
				rotateLeft(treePtr);
				break;
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::retrieveNode(Node<ItemT,KeyT>*&treePtr,KeyT &_key,ItemT &_item)
	throw(ATException)
{
	if(treePtr==NULL)
		throw ATException("found key item failed !");
	else if(_key<treePtr->item.getKey())
	{
		retrieveNode(treePtr->leftPtr,_key,_item);
	}
	else if(_key>treePtr->item.getKey())
	{
		retrieveNode(treePtr->rightPtr,_key,_item);
	}
	else
		_item=treePtr->item;
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::traverseNode(Node<ItemT,KeyT>*&treePtr,void (*visit)(ItemT _item))
{
	if(treePtr!=NULL)
	{
		traverseNode(treePtr->leftPtr,visit);
		visit(treePtr->item);
		traverseNode(treePtr->rightPtr,visit);
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::copy(Node<ItemT,KeyT> *&treePtr,Node<ItemT,KeyT>*&oldPtr)
	throw(ATException)
{
	if(oldPtr!=NULL)
	{
		treePtr=new Node<ItemT,KeyT>(oldPtr->item,NULL,NULL);
		if(treePtr==NULL)
			throw ATException("allocate memory failed !");
		treePtr->bal=oldPtr->bal;
		copy(treePtr->leftPtr,oldPtr->leftPtr);
		copy(treePtr->rightPtr,oldPtr->rightPtr);
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::destroy(Node<ItemT,KeyT>*& treePtr)
{
	if(treePtr!=NULL)
	{
		destroy(treePtr->leftPtr);
	    destroy(treePtr->rightPtr);
		delete treePtr;
		treePtr=NULL;	
	}
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::rotateLeft(Node<ItemT,KeyT> *&treePtr)
{
	Node<ItemT,KeyT>*temp=treePtr->rightPtr;
	treePtr->rightPtr=temp->leftPtr;
	temp->leftPtr=treePtr;
	treePtr=temp;
}

template<class ItemT,class KeyT>
void AvlTree<ItemT,KeyT>::rotateRight(Node<ItemT,KeyT>*&treePtr)
{
	Node<ItemT,KeyT> *temp=treePtr->leftPtr;
	treePtr->leftPtr=temp->rightPtr;
	temp->rightPtr=treePtr;
	treePtr=temp;
}


 

//=====================测试程序========================
#include<iostream>
#include<string>
#include<ctime>
#include<cstdlib>
#include"avl_tree_item.h"
#include"avl_tree.h"
#include"avl_tree.cpp"
using namespace std;
void display(Item<string,string> _item);
int main()
{
	//srand(time(0));
	AvlTree<Item<string,string>,string> atree;
	Item<string,string> newitem;
	string thekey,theval;
	cout<<"creating avl tree atree with 100 datas !"<<endl;
	for(int i=0;i<100;i++)
	{
		for(int j=0;j<10;j++)
		{
			thekey=thekey+char(rand()%26+'a');
			theval=theval+char(rand()%10+'0');
		}
		newitem.set(theval,thekey);
		try{
		atree.insert(newitem);
		thekey.clear();
		theval.clear();
		}catch(ATException &e)
		{
			cout<<e.what()<<endl;
		}
	}
	cout<<"the data in atree are :"<<endl;
	atree.traverse(display);
	cout<<"traverse the tree atree over !"<<endl;
	cout<<"enter the key word of the item (q to quit ):"<<endl;
	string keyword;
	cin>>keyword;
	while(keyword!="q")
	{
		try{
			atree.retrieve(keyword,newitem);
			display(newitem);
		}catch(ATException &e)
		{
			cout<<e.what()<<endl;
		}
		cout<<"enter other one key (q to quit): "<<endl;
		cin>>keyword;
	}
	cout<<"enter the key word of the item you want to delete (s to stop):"<<endl;
	cin>>keyword;
	while(keyword!="q")
	{
		try{
			atree.remove(keyword);
		}catch(ATException &e)
		{
			cout<<e.what()<<endl;
		}
		cout<<"enter other one key (s to stop):"<<endl;
		cin>>keyword;
	}
	cout<<"create a tree same as atree !"<<endl;
	AvlTree<Item<string,string>,string> btree(atree);
	cout<<"the date in btree :"<<endl;
	btree.traverse(display);
	cout<<"over !"<<endl;
	return 0;

}
void display(Item<string,string> _item)
{
	cout<< _item.getKey()<<'\t'<<_item.getVal()<<endl;
}


 

chenloug
关注
AVL树的实现
weixin_45155703的博客
07-04 245
AVL 树的创建
【C++】AVL树实现
最新发布
x_p96484685433的博客
05-11 1491
本文详细介绍了AVL树的概念、实现及其自平衡机制。AVL树是一种自平衡二叉搜索树，通过控制左右子树的高度差来保证查找效率。文章首先介绍了AVL树的基本概念和平衡因子的作用，接着详细讲解了AVL树的插入操作，包括平衡因子的更新和四种旋转操作（右单旋、左单旋、左右双旋、右左双旋）的实现。此外，文章还介绍了AVL树的查找、平衡检测和删除操作，并通过代码示例展示了如何实现这些功能。
AVL树实现
hojor的专栏
06-17 172
avl树是其每个节点的左子树和右子树的高度最多差1的二叉查找树。当在一棵avl树中插入节点的时候，很可能把avl树的平衡给破坏掉，在不平衡的情况下，可以通过对树做单次旋转或者复杂些的双旋转来处理。具体的旋转方法Google去 O(∩_∩)O，这里就不做详细介绍啦。下面仅给已实现的avl树的代码。 /*====================*\ | AvlTree.h | ...
avl树实现hash表
12-29
在本项目中，我们将讨论如何结合这两种数据结构，利用avl树实现哈希表，以达到更好的性能效果。 首先，让我们了解一下avl树。avl树是一种自平衡二叉搜索树（BST），它的特点是任何节点的两个子树的高度最大差别不...
基于Qt和Avl树实现登录系统【100013012】
07-19
通过实现这样一个登录系统，学生可以深入理解Qt的图形界面设计和Avl树的数据结构及其应用，同时锻炼到软件工程中的需求分析、设计、编码和测试等各个环节。 总结来说，这个项目结合了GUI开发和数据结构两大主题，...
C++平衡Avl树实现.zip
08-20
在这篇文章中，我们将深入探讨C++实现AVL树的关键知识点。 首先，我们需要理解AVL树的基本概念。AVL树是一种特殊的二叉搜索树，其特点是每个节点的两个子树的高度差不超过1，这确保了AVL树的高度平衡。这种平衡性...
AVL file:一个基于文件的AVL树实现的库。-开源
05-13
AVL文件库是一种高效的数据结构实现，它将高度平衡的AVL树与文件存储相结合，提供了线程安全的多键并发访问功能。AVL树，全称为Adelson-Velsky和Landis树，是一种自平衡的二叉查找树，其特点是任何节点的两个子树的...
simpleAVLTree:一个简单的AVL树实现
06-03
一个简单的 AVL 树实现。 安装 $ npm install --save simpleavltree 基本用法 var AVLTree = require ( 'simpleavltree' ) ; /** * Build the AVL tree */ var tree = new AVLTree ( 44 ) ; tree . insert ( 17 ...
avl树的实现
05-15
数据结构中avl树的实现，包含avl树的插入，删除节点，并以括号表示法输出结果
Java AVL树实现与源码解析
AVL树是一种自平衡的二叉搜索树（BSTree），由苏联计算机科学家Adelson-Velsky和Landis在1962年提出。...Java源码中的AVL树实现遵循了二叉搜索树的性质，并加入了自平衡的逻辑，确保了数据操作的高效率。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值