AVLTree / 憋错料

AVLTree

一.AVLTree的性质

1.左子树和右子树的高度差不超过1

2.左右子树都是AVL树

3.每一个节点都有一个平衡因子，任一点的平衡银子为（-1，0，1）

二.AVL树的效率

log2n

三.AVLTreeNode

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _parent;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;

	K _key;
	V _value;
	int _bf;

	AVLTreeNode(const K& key = K(), const V& value = V())
		:_parent(NULL)
		, _left(NULL)
		, _right(NULL)
		, _key(key)
		, _value(value)
		, _bf(0)
	{}

};

四.Insert接口

bool Insert(const K& key,const V& value)
	{
		if (_root == NULL)  //没有节点
		{
			_root = new Node(key, value);
			return true;
		}

		Node* cur = _root;
		Node* parent = NULL;

		while (cur) //找位置
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				break;
			}
		}

		Node* tmp = NULL;
		if (parent->_key < key)  //插入节点
		{
			tmp = new Node(key, value);
			parent->_right = tmp;
			tmp->_parent = parent;
		}
		else
		{
			tmp = new Node(key, value);
			parent->_left = tmp;
			tmp->_parent = parent;
		}

		bool isRotate = false;
		cur = tmp;
		parent = cur->_parent;

		while (parent)  //调节平衡因子
		{
			if (parent->_left == cur)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == -1 || parent->_bf == 1)
			{
				cur = parent;
				parent = cur->_parent;
			}
			else       //paernt->_bf == 2 || parent->_bf == -2
			{
				if (parent->_bf == 2)
				{
					if (cur->_bf == 1)
					{
						_RotateL(parent);
					}
					else
					{
						_RotateRL(parent);
					}
				}
				else    //parent->_bf == -2
				{
					if (cur->_bf == -1)
					{
						_RotateR(parent);
					}
					else
					{
						_RotateLR(parent);
					}
				}
				isRotate = true;
				break;
			}

		}

		if (isRotate)  //调整完需要将调整部分给上面的parent
		{
			Node* ppNode = parent->_parent;
			if (ppNode == NULL)
			{
				_root = parent;
			}
			else if (ppNode->_key > parent->_key)
			{
				ppNode->_left = parent;
			}
			else
			{
				ppNode->_right = parent;
			}
		}

	}

五.旋转

1.左旋

void _RotateL(Node*& parent)
	{
		Node* subR = parent->_right;
		Node* subRleft = subR->_left;

		parent->_right = subRleft;
		if (subRleft)
		{
			subRleft->_parent = parent;
		}
		subR->_left = parent;

		subR->_parent = parent->_parent;
		parent->_parent = subR;

		parent->_bf = 0;
		subR->_bf = 0;

		parent = subR;
	}

2.右旋

void _RotateR(Node*& parent)
	{
		Node* subL = parent->_left;
		Node* SubLright = subL->_right;

		parent->_left = SubLright;
		if (SubLright)
		{
			SubLright->_parent = parent;

		}
		subL->_right = parent;
		subL->_parent = parent->_parent;
		parent->_parent = subL;

		parent->_bf = 0;
		subL->_bf = 0;

		parent = subL;
	}

3.左右双旋

void _RotateLR(Node*& parent)
	{
		Node* pNode = parent;
		Node* subRNode = parent->_right;
		Node* subRLNode = subRNode->_left;
		int bf = subRLNode->_bf;

		_RotateL(parent->_left);
		_RotateR(parent);

		if (bf == -1)
		{
			subRNode->_bf = 0;
			pNode = -1;
		}
		else if (bf == 1)
		{
			subRNode->_bf = 1;
			pNode = 0;
		}
		else
		{
			subRNode->_bf = 0;
			pNode->_bf = 0;
		}
	}

4.右左双旋

void _RotateRL(Node*& parent)
	{
		Node* pNode = parent;
		Node* subLNode = parent->_left;
		Node* subLRNode = subLNode->_right;

		int bf = subLRNode->_bf;
		_RotateR(parent->_right);
		_RotateL(parent);

		if (bf == -1)   //特殊处理平衡因子
		{
			subLNode->_bf = 0;
			pNode->_bf = 1;
		}
		else if (bf == 1)
		{
			subLNode->_bf = -1;
			pNode->_bf = 0;
		}
		else
		{
			subLNode->_bf = 0;
			pNode->_bf = 0;
		}
	}

六.代码实现

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

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _parent;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;

	K _key;
	V _value;
	int _bf;

	AVLTreeNode(const K& key = K(), const V& value = V())
		:_parent(NULL)
		, _left(NULL)
		, _right(NULL)
		, _key(key)
		, _value(value)
		, _bf(0)
	{}

};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	AVLTree()
		:_root(NULL)
	{}

	bool Insert(const K& key,const V& value)
	{
		if (_root == NULL)
		{
			_root = new Node(key, value);
			return true;
		}

		Node* cur = _root;
		Node* parent = NULL;

		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				break;
			}
		}

		Node* tmp = NULL;
		if (parent->_key < key)
		{
			tmp = new Node(key, value);
			parent->_right = tmp;
			tmp->_parent = parent;
		}
		else
		{
			tmp = new Node(key, value);
			parent->_left = tmp;
			tmp->_parent = parent;
		}

		bool isRotate = false;
		cur = tmp;
		parent = cur->_parent;

		while (parent)
		{
			if (parent->_left == cur)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == -1 || parent->_bf == 1)
			{
				cur = parent;
				parent = cur->_parent;
			}
			else       //paernt->_bf == 2 || parent->_bf == -2
			{
				if (parent->_bf == 2)
				{
					if (cur->_bf == 1)
					{
						_RotateL(parent);
					}
					else
					{
						_RotateRL(parent);
					}
				}
				else    //parent->_bf == -2
				{
					if (cur->_bf == -1)
					{
						_RotateR(parent);
					}
					else
					{
						_RotateLR(parent);
					}
				}
				isRotate = true;
				break;
			}

		}

		if (isRotate)
		{
			Node* ppNode = parent->_parent;
			if (ppNode == NULL)
			{
				_root = parent;
			}
			else if (ppNode->_key > parent->_key)
			{
				ppNode->_left = parent;
			}
			else
			{
				ppNode->_right = parent;
			}
		}

	}

	Node* Find(const K& key);
	void Romove(const K& key);

	void LevelOrder()
	{
		return _LevelOrder(_root);
		cout << endl;
	}

	bool Isbalance()//判断是否为AVLTree
	{
		return _Isbalance(_root);
	}

protected:
	void _RotateL(Node*& parent)
	{
		Node* subR = parent->_right;
		Node* subRleft = subR->_left;

		parent->_right = subRleft;
		if (subRleft)
		{
			subRleft->_parent = parent;
		}
		subR->_left = parent;

		subR->_parent = parent->_parent;
		parent->_parent = subR;

		parent->_bf = 0;
		subR->_bf = 0;

		parent = subR;
	}

	void _RotateR(Node*& parent)
	{
		Node* subL = parent->_left;
		Node* SubLright = subL->_right;

		parent->_left = SubLright;
		if (SubLright)
		{
			SubLright->_parent = parent;

		}
		subL->_right = parent;
		subL->_parent = parent->_parent;
		parent->_parent = subL;

		parent->_bf = 0;
		subL->_bf = 0;

		parent = subL;
	}

	void _RotateRL(Node*& parent)
	{
		Node* pNode = parent;
		Node* subLNode = parent->_left;
		Node* subLRNode = subLNode->_right;

		int bf = subLRNode->_bf;
		_RotateR(parent->_right);
		_RotateL(parent);

		if (bf == -1)
		{
			subLNode->_bf = 0;
			pNode->_bf = 1;
		}
		else if (bf == 1)
		{
			subLNode->_bf = -1;
			pNode->_bf = 0;
		}
		else
		{
			subLNode->_bf = 0;
			pNode->_bf = 0;
		}
	}

	void _RotateLR(Node*& parent)
	{
		Node* pNode = parent;
		Node* subRNode = parent->_right;
		Node* subRLNode = subRNode->_left;
		int bf = subRLNode->_bf;

		_RotateL(parent->_left);
		_RotateR(parent);

		if (bf == -1)
		{
			subRNode->_bf = 0;
			pNode = -1;
		}
		else if (bf == 1)
		{
			subRNode->_bf = 1;
			pNode = 0;
		}
		else
		{
			subRNode->_bf = 0;
			pNode->_bf = 0;
		}
	}

	void _LevelOrder(Node* root)
	{
		if (root == NULL)
			return;

		_LevelOrder(root->_left);
		cout << root->_key << " ";
		_LevelOrder(root->_right);
	}

	int _Height(Node* root)  //计算高度
	{
		if (root == NULL)
			return 0;

		int left = _Height(root->_left);
		int right = _Height(root->_right);

		return left > right ? left + 1 : right + 1;
	}

	bool _Isbalance(Node* root)
	{
		if (root == NULL)
			return true;

		int bf = _Height(root->_left) - _Height(root->_right);

		if (bf != root->_bf)
		{
			cout << "error!" << root->_key << " ";
		}

		return (bf = root->_bf && _Isbalance(root->_left) && _Isbalance(root->_right));
	}
protected:
	Node* _root;
};

void TestAVLTree()
{
	AVLTree<int, int> at;
	int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };

	for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		at.Insert(a[i],1);
	}

	at.LevelOrder();
	cout << endl;
	cout << at.Isbalance() << endl;
}

以上就是本人在学习过程中的一些经验总结。当然，本人能力有限，难免会有纰漏，希望大家可以指正。

时间： 2024-11-10 07:56:14

AVLTree的相关文章

基本数据结构之AvlTree

问题描述: AvlTree 问题分析: 基本的实现代码实现: package c04; /** * @project: DataStructureAndAlgorithmAnalysis * @filename: AvlTree.java * @version: 0.10 * @author: JM Han * @date: 15:04 2015/10/21 * @comment: Test Purpose * @result: */ import master.Underfl

hdu 4006/AvlTree

原题链接:http://acm.hdu.edu.cn/showproblem.php?pid=4006 这道题以前用c语言写的Avltree水过了.. 现在接触了c++重写一遍... 由于没有删除操作故不带垃圾回收,具体如下: 1 #include<cstdio> 2 #include<cstdlib> 3 #include<iostream> 4 #define Max_N 1000100 5 inline int max(int &a, int &b

Java实现平衡二叉树（AVLTree）的构建

最近在学习数据结构上关于平衡二叉树的知识,看了严老师的思路,感觉用java写出递归的构建方式有点困难,因为其中的递归需要把引用传进去,所以感觉是要实现起来比较麻烦,所以就首先想到使用非递归的方式来实现构建平衡二叉树. 使用非递归的方式,思路也很简单,就是为每一个结点都要定义一个平衡因子的属性,当成功向树中插入一个数据时,我就要进行回溯,看看有没有平衡因子的绝对值等于2的结点,如果有,那就需要进行旋转.当时的思路仅限于这些,接触java没有多久,目测如果实现起来,有点困难. 所以,上网查询了一个博

AVLTree的实现算法(C++实现)

#include<stack> #include<utility> #include<allocators> #include<functional> using std::pair; using std::allocator; using std::less; using std::stack; #ifndef AVLTreeH #define AVLTreeH enum {RH=-1,EH=0,LH=1}; template<typename T&

平衡二叉树(AVLTREE,双链表实现)

首先说下好久没更新了,最近打游戏和工作都有点多,o(^▽^)o. 写这个AVL发现自己的代码风格好差,尤其是变量命名这块,后来意识到了,想去改,但是太多了,改了几个就不想改了,做这个是记录下自己的成长吧. 另外说下,调这个AVL真心有点烦了,前面写了一个,但是逻辑有点乱,基本的删除都测差不多ok了,发现一个bug,实在不想去看那代码,太乱了,后来强b这自己去重新写,花了1个多小时(当然是加班的时候理),理清了,晚上9点多回来,大概3个小时,把del这块从新改完了,写代码真的是一个时候一个思想,发

POJ 2418 Hardwood Species( AVL-Tree )

#include <stdio.h> #include <stdlib.h> #include <math.h> #include <string.h> typedef struct AVLTree{ char name[31]; int nCount; int nHeight; struct AVLTree* pLeft; struct AVLTree* pRight; }AVLTree; int Max( int a, int b ); int Heig

c++ AVLTree(高度平衡的搜索二叉树)

#pragma once #include <iostream> using namespace std; #define NEG -1 #define ZERO 0 #define POS 1 template <class K,class V> struct AVLTreeNode//树的节点 { K _key; V _value; AVLTreeNode* _left; AVLTreeNode* _right; AVLTreeNode* _parent; int _bf;

平衡搜索树—AVLTree

AVL是平衡搜索二叉树,它的主要特点在于:(1)左子树和右子树的高度差绝对值<1,(2)树中的每个子树都是AVL树,(3)每个节点都有一个平衡因子(-1.0.1),平衡因子的大小等于右子树的高度减左子树的高度下面就是一个AVL树: 其中,这个树满足左子树和右子树的高度差绝对值小于1,每个节点的平衡因子都满足条件. 下面是AVLTree中节点的结构: template <class K, class V> struct AVLTreeNode { K _key;

AVLTree的节点删除

当年实现自己的共享内存模板的时候,map和set的没有实现,本来考虑用一个AVLTree作为底层实现的,为啥,因为我当时的数据结构知识里面我和RBTree不熟,只搞过AVLTree,但当时我一直没有看过删除如何实现.结果Scottxu跳出来,参考STLport的实现,迅速用RBTree搞掂了.搞得这个代码的头文件也就一直放在那儿,7-8年后,整理这个代码,看看Scottxu代码的底子,觉得挺不错的,觉得Copy改造一个AVLTree的实现应该很容易,就上手了. AVL的插入无话可说,就是参考严蔚