AVLTree

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

这回好不容易做出来的数据结构是AVLTree，做之前犹豫了好久，做的时候浪费了很多时间，做完之后还是觉得不够优化。

比如在平衡因子那一块，我不知道什么时候什么情况更新平衡因子，只好用最蠢的办法递归找。这里会浪费很多时间。

多说无益贴代码了

/*
	Author: Triose
	Data:   2016.4.8
	Mail:   triose@163.com
 */

#ifndef AVLTREE_H
#define AVLTREE_H

#include<iostream>
using namespace std;

//template<class T> T Max(T a, T b) { return a > b ? a : b; }	//用于求树高， 没用了

template<class T>
class TreeElmt {					//树节点定义，适当情况适当改装
public:
	T data;
	TreeElmt * left;
	TreeElmt * right;
	bool hidden;
	int factor;
	TreeElmt(T data_) {
		this->data = data_;
		this->left = NULL;
		this->right = NULL;
		this->hidden = false;
		this->factor = 0;
	}
};

template<class T>
class AVLTree {
public:
	TreeElmt<T> *root;
	int size;
	AVLTree() {
		this->root = NULL;
		this->size = 0;
	}
	void destroy(TreeElmt<T> * _root) {
		if (_root == NULL) {
			return;
		}
		destroy(_root->left);
		destroy(_root->right);
		delete _root;
		_root = NULL;
		return;
	}
	~AVLTree() {
		destroy(this->root);
	}

	int get_high(TreeElmt<T> * _root) {
		if (!_root) {
			return -1;
		}
		if (_root->factor >= 0) {
			return get_high(_root->left) + 1;
		}
		else
			return get_high(_root->right) + 1;
		//return Max(get_high(_root->left), get_high(_root->right)) + 1;		//其实不需要这个了。如果该节点平衡因子大于等于0，则返回左子树高度加一，否则返回右子树高度加一
	}

	int get_factor(TreeElmt<T> * _root) {
		return get_high(_root->left) - get_high(_root->right);
	}

	void rotate_left(TreeElmt<T> ** _froot) {
		TreeElmt<T> * _root = (_froot ? (*_froot)->left : this->root);						//此处为平衡因子最先变成2的节点
		TreeElmt<T> * left = _root->left;
		if (left->factor == 1) {
			/* LL rotate. */
			_root->left = left->right;
			left->right = _root;
			if (_froot) {
				(*_froot)->left = left;
			}
			else {
				this->root = left;
			}
			_root->factor = 0;
			left->factor = 0;
			return;
		}
		else {
			/* LR rotate. */
			TreeElmt<T> * gchild = left->right;
			left->right = gchild->left;
			gchild->left = left;
			_root->left = gchild->right;
			gchild->right = _root;
			if (_froot) {
				(*_froot)->left = gchild;
			}
			else {
				this->root = gchild;
			}
			switch (gchild->factor) {
			case 1: _root->factor = -1; left->factor = 0; break;
			case 0: _root->factor = 0; left->factor = 0; break;
			case -1: _root->factor = 0; left->factor = 1; break;
			}
			gchild->factor = 0;
			return;
		}
	}

	void rotate_right(TreeElmt<T> ** _froot) {
		TreeElmt<T> * _root = (_froot ? (*_froot)->right : this->root);
		TreeElmt<T> * right = _root->right;
		if (right->factor == -1) {
			/* RR ratate. */
			_root->right = right->left;
			right->left = _root;
			if (_froot) {
				(*_froot)->right = right;
			}
			else {
				this->root = right;
			}
			_root->factor = 0;
			right->factor = 0;
			return;
		}
		else {
			/* RL rotate. */
			TreeElmt<T> * gchild = right->left;
			right->left = gchild->right;
			gchild->right = right;
			_root->right = gchild->left;
			gchild->left = _root;
			if (_froot) {
				(*_froot)->right = gchild;
			}
			else {
				this->root = gchild;
			}
			switch (gchild->factor) {
			case 1: _root->factor = 0; right->factor = -1; break;
			case 0: _root->factor = 0; right->factor = 0; break;
			case -1: _root->factor = 1; right->factor = 0; break;
			}
			gchild->factor = 0;
		}
	}
	void ins(TreeElmt<T> ** _froot, TreeElmt<T> ** _root, T data_) {		//作为ADTree的插入没有问题
		if (!(*_root)) {
			*_root = new TreeElmt<T>(data_);
			this->size++;
			return;
		}
		if ((*_root)->data == data_) {			//看节点是否被隐藏，如果不被隐藏则不做任何操作
			if ((*_root)->hidden == true) {
				(*_root)->hidden = false;
			}
		}
		else if ((*_root)->data < data_) {		//插入右边
			ins(_root, &((*_root)->right), data_);
			(*_root)->factor = get_factor(*_root);//更新平衡因子
		}
		else {									//插入左边
			ins(_root, &((*_root)->left), data_);
			(*_root)->factor = get_factor(*_root);//更新平衡因子
		}
		/*现在判断要不要旋转，以及怎么旋转*/
		if ((*_root)->factor == 2) {
			rotate_left(_froot);
		}
		else if ((*_root)->factor == -2) {
			rotate_right(_froot);
		}
	}
	void rem(TreeElmt<T> * _root, T data_) {		//惰性移除
		if (_root == NULL)
			return;
		if (_root->data == data_) {
			_root->hidden = true;
			return;
		}
		else if (_root->data < data_) {
			rem(_root->right, data_);
		}
		else {
			rem(_root->left, data_);
		}
		return;
	}
	void Debug(TreeElmt<T> * _root) {				//For Debug
		if (!_root)
			return;
		Debug(_root->left);
		if (!_root->hidden)
			cout << _root->data << " " << _root->factor << endl;
		Debug(_root->right);
		return;
	}
};



#endif // !AVLTREE_H


2016.4.12更新

上面的代码还是忽悠忽悠人吧，运行的时候太慢而且会出问题，因为树的规模一旦很大，递归来更新树高和平衡因子肯定不行，而且， C++的效率很不如C，如果在oj上用template这种东西超时的几率是很大的！

下面更新纯C模板。

#include<stdio.h>
#include<stdlib.h>

#define TYPE Node

typedef struct Node_ {
	int num;
}Node;
Node* creatNode(int num_) {
	Node *newnode = (Node *)malloc(sizeof(Node));
	newnode->num = num_;
	return newnode;
}

typedef struct TreeElmt_{
	void * data;
	int hight;
	int factor;
	int hidden;
	struct TreeElmt_ * left;
	struct TreeElmt_ * right;
}TreeElmt;

TreeElmt * creatElmt(void * data_) {
	TreeElmt * newelement = (TreeElmt *)malloc(sizeof(TreeElmt));
	newelement->data = (void *)data_;
	newelement->left = NULL;
	newelement->right = NULL;
	newelement->factor = 0;
	newelement->hight = 0;
	newelement->hidden = 0;
	return newelement;
}

typedef struct AVLTree_ {
	TreeElmt * root;
	int size;
}AVLTree;

void AVL_destroy(TreeElmt * _root) {
	if (!_root)
		return;
	AVL_destroy(_root->left);
	AVL_destroy(_root->right);
	free(_root);
	_root = NULL;
	return;
}
void AVL_init(AVLTree * tree) {
	AVL_destroy(tree->root);
	tree->root = NULL;
	tree->size = 0;
}

int cmp(TYPE a, TYPE b) {	//a < b return -1;		直接写结构体的比较函数即可
	if (a.num < b.num)
		return -1;
	else if (a.num == b.num)
		return 0;
	return 1;
}
void AVL_rem(TreeElmt * _root, void * data_) {
	if (!_root)
		return;
	int ans = cmp(*((TYPE *)(_root->data)), *((TYPE *)(data_)));
	switch (ans) {
	case -1: AVL_rem(_root->right, data_); break;
	case 0:  _root->hidden = 1;free(data_); break;
	case 1:  AVL_rem(_root->left, data_); break;
	}
	return;
}
void reflash(TreeElmt * _root) {						//更新树高和平衡因子
	int lh = _root->left ? _root->left->hight : -1;
	int rh = _root->right ? _root->right->hight : -1;
	_root->factor = lh - rh;
	_root->hight = lh > rh ? (lh + 1) : (rh + 1);
	return;
}


void left_rotate(AVLTree * tree, TreeElmt ** _froot) {
	TreeElmt * _root = (_froot) ? (*_froot)->left : tree->root;
	TreeElmt * left = _root->left;
	if (left->factor == 1) {
		/* LL rotate.*/
		_root->left = left->right;
		left->right = _root;
		if (_froot) {
		(*_froot)->left = left;
		}
		else {
		tree->root = left;
		}
		_root->factor = 0;					//重置平衡因子并且更新树高（更新树高的顺序不能变！）
		left->factor = 0;
		reflash(_root);
		reflash(left);
		if (_froot) {
			reflash(*_froot);
		}
		return;
	}
	else {
		/* LR rotate.*/
		TreeElmt * gchild = left->right;
		left->right = gchild->left;
		gchild->left = left;
		_root->left = gchild->right;
		gchild->right = _root;
		if (_froot) {
		(*_froot)->left = gchild;
		}
		else {
		tree->root = gchild;
		}
		switch (gchild->factor) {
		case 1: _root->factor = -1; left->factor = 0; break;
		case 0: _root->factor = 0; left->factor = 0; break;
		case -1: _root->factor = 0; left->factor = 1; break;
		}
		gchild->factor = 0;				//重置平衡因子并且更新树高
		reflash(left);
		reflash(_root);
		reflash(gchild);
		if (_froot)
			reflash(*_froot);
		return;
	}
}
void right_rotate(AVLTree * tree, TreeElmt ** _froot) {
	TreeElmt * _root = (_froot ? (*_froot)->right : tree->root);
	TreeElmt * right = _root->right;
	if (right->factor == -1) {
		/* RR ratate.*/
		_root->right = right->left;
		right->left = _root;
		if (_froot) {
		(*_froot)->right = right;
		}
		else {
		tree->root = right;
		}
		_root->factor = 0;					//重置平衡因子并且更新树高
		right->factor = 0;
		reflash(_root);
		reflash(right);
		if (_froot) {
			reflash(*_froot);
		}
		return;
	}
	else {
		/* RL rotate.*/
		TreeElmt * gchild = right->left;
		right->left = gchild->right;
		gchild->right = right;
		_root->right = gchild->left;
		gchild->left = _root;
		if (_froot) {
		(*_froot)->right = gchild;
		}
		else {
		tree->root = gchild;
		}
		switch (gchild->factor) {
		case 1: _root->factor = 0; right->factor = -1; break;
		case 0: _root->factor = 0; right->factor = 0; break;
		case -1: _root->factor = 1; right->factor = 0; break;
		}
		gchild->factor = 0;
		reflash(right);
		reflash(_root);
		reflash(gchild);
		if (_froot)
			reflash(*_froot);
		return;
	}
}

void AVL_ins(AVLTree * tree, TreeElmt ** _froot, TreeElmt ** _root, void * data_) {
	if (!*_root) {
		(*_root) = creatElmt(data_);
		tree->size++;
		return;
	}
	int ans = cmp(*((TYPE*)((*_root)->data)), *((TYPE*)(data_)));		//比较函数
	switch (ans) {
	case 1: AVL_ins(tree, _root, &((*_root)->left), data_); reflash(*_root); break;
	case 0: {
		if ((*_root)->hidden) {
			(*_root)->hidden = 0;
			free(data_);
			}
			break;
		}
	case -1: AVL_ins(tree, _root, &((*_root)->right), data_); reflash(*_root); break;
	}
	switch ((*_root)->factor) {
	case 2: left_rotate(tree, _froot);break;
	case -2: right_rotate(tree, _froot);break;
	default: break;
	}
	return;
}
void Debug(TreeElmt * _root) {
	if (!_root)
		return;
	Debug(_root->left);
	printf("%d %d\n", ((Node*)_root->data)->num, _root->factor);
	Debug(_root->right);
}


AVLTree tree;

int main() {
	AVL_init(&tree);
	AVL_ins(&tree, NULL, &(tree.root), creatNode(27));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(45));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(34));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(20));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(11));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(59));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(10));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(25));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(29));
	AVL_ins(&tree, NULL, &(tree.root), creatNode(30));
	Debug(tree.root);
	putchar(10);
}
没有很周全的测试，不过也应该差不多了

Triose_Stream
关注
专栏目录
【c++】模板
gogo小Sa的专栏
05-12 443
【c++】模板一．模板的概念        1. 什么是模板        2. 模板的作用        3. 模板的语法二．函数模板三．类模板四．模板的编译类型 参考：《c++从入门到精通》 人民邮电出本社    在制作ppt时，我们可以使用模板，其中已为我们提供了基本元素，只需要自己填入相应数据即可。在C++中，也有这样的模板，只需在使用前填入自己需要的数据类型即可。    模板是c++语音...
模板函数调用
fireeeea的博客
04-24 4679
#include&lt;iostream&gt;using namespace std;template &lt;class t&gt;t MAX(t a,t b){    cout&lt;&lt;"模板一被调用"&lt;&lt;endl; }template&lt;class T1,class T2&gt;T1 MAX(T1 a,T2 b){    cout&lt;&lt;"函数二
第16周上机实践项目3——max带来的冲突
Beyond the Sora
06-21 1026
分析下面程序出现的编译错误，给出解决的方案。#include<iostream> using namespace std; //定义函数模板 template<class T> T max(T a, T b) { return (a>b)?a:b; }int main() { int x=2,y=6; double x1=9.123,y1=12.6543; cout<
实验八 模板
AIIN的博客
06-26 700
实验目的和要求 1.能够使用C++模板机制定义重载函数。 2.能够实例化及使用模板函数。 3.能够实例化和使用模板类。 4.应用标准C++模板库（STL）通用算法和函数对象实现查找和排序。 实验内容 1.分析并调试下列程序，了解函数模板的使用。 //sy8_1.cpp #include&amp;amp;amp;lt;iostream&amp;amp;amp;gt; using namespace std; templa...
c++基础学习笔记——04-c++day08
Alliswell_WP
06-14 220
在学习c++基础总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 04-c++day08 目录：一、C++模板1、函数模板基本使用2、课堂练习-实现通用的数组排序3、函数模板和普通函数区别4、函数模板和普通函数在一起调用规则5、模板机制6、函数模板的局限性7、类模板的基本使用8、成员函数创建时机9、类模板做函数的参数10、类模板碰到继承的问题以及解...
avltree算法.rar_avl_avl tree
09-21
在"www.pudn.com.txt"和"AVLTree"这两个文件中，可能包含了关于AVL树的更多详细信息，如实现代码、示例或进一步的解释。学习AVL树不仅能够理解其基本概念和操作，还能深入理解数据结构的设计和优化，这对于理解和...
AVltree_avltree_
09-30
4. `avltree_test`：这个可能是编译后的可执行文件，当运行这个文件时，它会执行`avltree_test.c`中的测试代码，展示AVL树的运作情况。 关于AVL树的实现，主要涉及以下几个核心概念： - **节点定义**：每个节点...
AVLTree.rar_avl_java avltree_tree
09-24
AVLTree.java文件应该包含了AVL树的实现，包括节点类的定义、插入、删除、旋转等核心功能。通过阅读和理解这个源代码，你可以深入学习AVL树的原理和操作，这对于理解和使用自平衡二叉查找树是非常有价值的。在实际...
AVLtree.zip_avl_avl java_avl tree_avltree_class A
09-19
AVL tree using node from data structure and algorithm java class, create a minimum AVL tree with minimum number of nodes at given high
PAT 1066 Root of AVL Tree_avltree_
10-01
4. **代码实现**：`PAT 1066 Root of AVL Tree.cpp` 文件可能包含了实现AVL树的基本数据结构、插入、删除和平衡调整的函数。在实际编程中，通常会定义一个AVL树节点结构体，包含键值、子节点指针、以及平衡因子。...
C++面试题
热门推荐
backard的专栏
01-20 5万+
1.构造一个类MySingleton,使该类只能存在一个实例. 思路:     将构造函数写为private的，然后通过一个成员静态函数来调用构造函数即可:) 例: #include "iostream.h" class MySingleton { private: static MySingleton* _instance; MySingleton(){ cout ~MyS
《C++语言基础》实践参考——max带来的冲突
迂者-贺利坚的专栏
06-16 1919
返回：贺老师课程教学链接 项目要求【项目3-max带来的冲突】 分析下面程序出现的编译错误，给出解决的方案。#include<iostream> using namespace std; //定义函数模板 template<class T> T max(T a, T b) { return (a>b)?a:b; }int main() { int x=2,y=6; dou
《程序设计实习》之【模板】
beashaper_的博客
06-10 607
函数模板 类模板 函数模板 泛型程序设计 Generic Programmin 算法实现时不指定具体要操作的数据的类型 泛型 —— 算法实现一遍 -&amp;gt; 适用于多种数据结构 优势：减少重复代码的编写 大量编写模板，使用模板的程序设计 -函数模板 类模板 函数模板 为了交换两个int变量的值，需要编写如下Swap函数： void Swap(int &amp;amp; x...
第八章——实验
yuzhouli111222的博客
06-22 323
实验目的和要求 1.能够使用C++模板机制定义重载函数。 2.能够实例化及使用模板函数。 3.能够实例化和使用模板类。 4.应用标准C++模板库（STL）通用算法和函数对象实现查找和排序。 实验内容 1.分析并调试下列程序，了解函数模板的使用。 #include&lt;iostream&gt; using namespace std; template &lt...
linux C下struct定义类的error：“unknown type name"
轩令的技术博客
12-24 4万+
今天本来已经把其他输出输入输出的地方调通了，但是遇到了这个问题，无论我这个定义的struct是在.c文件的上面，或者是被包含的.h文件中，都显示error：“unknown type name" struct _ksw_data { int * qlen; uint8_t *query; int * tlen; uint8_t * target; int m; int8_t *mat;...
codeforces 675C
Triose_Stream的博客
05-23 1845
标签是有个datastruct，but！ 这是个纯思维题。。 C. Money Transfers time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output There are
离散化的操作
Triose_Stream的博客
08-29 928
主要出现在有double的区间问题（建区间树时）和一些虽然是整型但是范围太大时等（无法保存或者枚举），我们可以发现，范围中很大部分数是相同的，那我们就可以保存区间端点或者范围边界来达到缩小数据的范围。 具体做法是把区间排序去重，然后每两个相邻坐标就能形成新的离散化后的区间。 三道题： 第一题： 221 uva 第二题： 2528 poj 第三题： 12171 uva
一些数据结构的实现
Triose_Stream的博客
08-24 844
11988(uva)意思是，你要输入一个字符串，遇到 [ 时按home键， 遇到 ] 时按end键， 然后问你最终这个字符串是什么 SampleInput This_is_a_[Beiju]_text [[]][][]Happy_Birthday_to_Tsinghua_University SampleOutput BeijuThis_is_a__text Happy_Birthday
avl tree insertion
最新发布
04-06
AVL树插入是指在AVL树中添加新元素的过程。在插入元素后，AVL树需要进行平衡操作，以保证树的高度平衡，即左右子树的高度差不超过1。平衡操作有四种：左旋、右旋、左右旋和右左旋。通过这些操作，AVL树可以自我调整...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值