[算法] avl树实现
大二的时候数据结构课死活没看懂的一个东东,看了2小时,敲了2小时,调了2小时。。。
平衡树某一节点的左右子树高度相差大于1的时候即需要调整,调整可分为四中情况 ll,rr,lr,rl其中lr,rl是由不同顺序的ll,rr来实现的,代码比想象的简短。
一棵平衡的树只有在插入和删除节点的时候,才会变的不平衡,所以掌握好时机,判断平衡是否破坏及不平衡的种类,再纠正即可
代码如下。。
avl.h
struct AVLNode {
struct AVLNode *left;
struct AVLNode *right;
int data;
int height;
}; static const int AVL_STATUS_OK = 0;
static const int AVL_STATUS_FOUNDED = 1;
static const int AVL_STATUS_NOTFOUNDED = 2;
static const int AVL_STATUS_FAILED = -1; int avl_insert(struct AVLNode **root, int data);
int avl_find(struct AVLNode *root, int data);
int avl_del(struct AVLNode **root, int data);
int avl_del_tree(struct AVLNode *root);
void print_avl_tree(struct AVLNode *root);
int _get_height(struct AVLNode *node);
int _max(int a, int b);
void _single_rotate_left(struct AVLNode **node);
void _single_rotate_right(struct AVLNode **node);
void _double_rotate_left_right(struct AVLNode **node);
void _double_rotate_right_left(struct AVLNode **node);
avl.c
#include <stdio.h>
#include <stdlib.h>
#include <assert.h> #include "avl.h" int avl_insert(struct AVLNode **ptr_root, int data) {
int ret;
if(NULL == *ptr_root) {
*ptr_root = malloc(sizeof(struct AVLNode));
if(NULL == *ptr_root) {
return AVL_STATUS_FAILED;
}
(*ptr_root)->data = data;
(*ptr_root)->left = NULL;
(*ptr_root)->right = NULL;
(*ptr_root)->height = 0;
return AVL_STATUS_OK;
} if(data == (*ptr_root)->data) {
return AVL_STATUS_OK;
}
else if(data < (*ptr_root)->data) {
ret = avl_insert(&((*ptr_root)->left), data);
if(_get_height((*ptr_root)->left) - _get_height((*ptr_root)->right) > 1){
if(data < (*ptr_root)->left->data){
_single_rotate_left(ptr_root);
}
else {
_double_rotate_left_right(ptr_root);
}
}
}
else {
ret = avl_insert(&((*ptr_root)->right), data);
if(_get_height((*ptr_root)->right) - _get_height((*ptr_root)->left) > 1){
if(data > (*ptr_root)->right->data) {
_single_rotate_right(ptr_root);
}
else {
_double_rotate_right_left(ptr_root);
}
}
}
(*ptr_root)->height = _max(_get_height((*ptr_root)->left), _get_height((*ptr_root)->right)) + 1;
return ret;
} int avl_find(struct AVLNode *root, int data) {
if(NULL == root) {
return AVL_STATUS_NOTFOUNDED;
}
if(data == root->data) {
return AVL_STATUS_FOUNDED;
}
if(data < root->data) {
return avl_find(root->left, data);
}
else {
return avl_find(root->right, data);
}
} int avl_del(struct AVLNode **root, int data) {
struct AVLNode *t;
if(*root == NULL) {
return AVL_STATUS_OK;
}
if(data < (*root)->data) {
avl_del(&((*root)->left), data);
if(_get_height((*root)->right) - _get_height((*root)->left) > 1){
if((*root)->right->left != NULL && (_get_height((*root)->right->left) > _get_height((*root)->right->right))) {
_double_rotate_right_left(root);
}
else {
_single_rotate_right(root);
}
}
}
else if(data > (*root)->data) {
avl_del(&((*root)->right), data);
if(_get_height((*root)->left) - _get_height((*root)->right) > 1){
if((*root)->left->right != NULL && (_get_height((*root)->left->right) > _get_height((*root)->left->left))) {
_double_rotate_left_right(root);
}
else {
_single_rotate_left(root);
}
}
}
else {
if(NULL != (*root)->left && NULL != (*root)->right) {
t = (*root) -> right;
while(t->left != NULL) {
t = t->left;
}
(*root) -> data = t->data;
avl_del(&((*root)->right), t->data);
if(_get_height((*root)->left) - _get_height((*root)->right) > 1){
if((*root)->left->right != NULL && (_get_height((*root)->left->right) > _get_height((*root)->left->left))) {
_double_rotate_left_right(root);
}
else {
_single_rotate_left(root);
}
}
}
else {
t = *root;
if((*root)->left == NULL) {
*root = (*root) -> right;
}
else if((*root)->right == NULL) {
*root = (*root) -> left;
}
free(t);
}
}
return AVL_STATUS_OK;
} int avl_del_tree(struct AVLNode *root) {
if(NULL == root) {
return AVL_STATUS_OK;
}
avl_del_tree(root->left);
avl_del_tree(root->right);
free(root);
return AVL_STATUS_OK;
} int _get_height(struct AVLNode *node) {
if(NULL == node){
return -1;
}
else{
return node->height;
}
} int _max(int a, int b) {
return a > b ? a:b;
} void _single_rotate_left(struct AVLNode **node) {
struct AVLNode* root = *node;
*node = root->left;
root->left = (*node)->right;
(*node)->right = root;
root->height = _max(_get_height(root->left), _get_height(root->right)) + 1;
(*node)->height = _max(_get_height((*node)->left), _get_height((*node)->right)) + 1;
} void _single_rotate_right(struct AVLNode **node) {
struct AVLNode* root = *node;
*node = root->right;
root->right = (*node)->left;
(*node)->left = root;
root->height = _max(_get_height(root->left), _get_height(root->right)) + 1;
(*node)->height = _max(_get_height((*node)->left), _get_height((*node)->right)) + 1;
} void _double_rotate_left_right(struct AVLNode **node) {
struct AVLNode* root = *node;
_single_rotate_right(&(root->left));
_single_rotate_left(node);
} void _double_rotate_right_left(struct AVLNode **node) {
struct AVLNode* root = *node;
_single_rotate_left(&(root->right));
_single_rotate_right(node);
} void print_avl_tree(struct AVLNode *node) {
if(NULL == node) {
return;
}
print_avl_tree(node->left);
printf("%d\t%d\n", node->data, node->height);
print_avl_tree(node->right);
}
main.c
#include <stdio.h> #include "avl.h" int main() {
struct AVLNode *root = NULL;
int ret = avl_insert(&root, 7);
printf("hello, world\n");
printf("root:address %ld\n", (long)root);
printf("after:%d\n", 7);
print_avl_tree(root);
avl_insert(&root, 6);
printf("after:%d\n", 6);
print_avl_tree(root);
avl_insert(&root, 5);
printf("after:%d\n", 5);
print_avl_tree(root);
avl_insert(&root, 7);
printf("after:%d\n", 7);
print_avl_tree(root);
avl_insert(&root, 1);
printf("after:%d\n", 1);
print_avl_tree(root);
avl_insert(&root, 0);
printf("after:%d\n", 0);
print_avl_tree(root);
avl_insert(&root, 9);
printf("after:%d\n", 9);
print_avl_tree(root); ret = avl_find(root, 7);
printf("find 7 result is %d\n", ret); ret = avl_find(root, 17);
printf("find 17 result is %d\n", ret); ret = avl_del(&root, 7);
printf("del 7 result is %d\n", ret);
print_avl_tree(root); ret = avl_del(&root, 17);
printf("del 17 result is %d\n", ret);
print_avl_tree(root); avl_del_tree(root);
return 0;
}
#gcc -g main.c avl.c -o main
#./main
hello, world
root:address 27951120
after:7
7 0
after:6
6 0
7 1
after:5
5 0
6 1
7 0
after:7
5 0
6 1
7 0
after:1
1 0
5 1
6 2
7 0
after:0
0 0
1 1
5 0
6 2
7 0
after:9
0 0
1 1
5 0
6 2
7 1
9 0
find 7 result is 1
find 17 result is 2
del 7 result is 0
0 0
1 1
5 0
6 2
9 0
del 17 result is 0
0 0
1 1
5 0
6 2
9 0
应该是正确的。
[算法] avl树实现的更多相关文章
- 数据结构与算法——AVL树类的C++实现
关于AVL树的简单介绍能够參考:数据结构与算法--AVL树简单介绍 关于二叉搜索树(也称为二叉查找树)能够參考:数据结构与算法--二叉查找树类的C++实现 AVL-tree是一个"加上了额外 ...
- 数据结构和算法(Golang实现)(28)查找算法-AVL树
AVL树 二叉查找树的树高度影响了查找的效率,需要尽量减小树的高度,AVL树正是这样的树. 一.AVL树介绍 AVL树是一棵严格自平衡的二叉查找树,1962年,发明者Adelson-Velsky和La ...
- [数据结构与算法] : AVL树
头文件 typedef int ElementType; #ifndef _AVLTREE_H_ #define _AVLTREE_H_ struct AvlNode; typedef struct ...
- 数据结构和算法(Golang实现)(29)查找算法-2-3树和左倾红黑树
某些教程不区分普通红黑树和左倾红黑树的区别,直接将左倾红黑树拿来教学,并且称其为红黑树,因为左倾红黑树与普通的红黑树相比,实现起来较为简单,容易教学.在这里,我们区分开左倾红黑树和普通红黑树. 红黑树 ...
- 算法与数据结构(十一) 平衡二叉树(AVL树)
今天的博客是在上一篇博客的基础上进行的延伸.上一篇博客我们主要聊了二叉排序树,详情请戳<二叉排序树的查找.插入与删除>.本篇博客我们就在二叉排序树的基础上来聊聊平衡二叉树,也叫AVL树,A ...
- AVL树的平衡算法(JAVA实现)
1.概念: AVL树本质上还是一个二叉搜索树,不过比二叉搜索树多了一个平衡条件:每个节点的左右子树的高度差不大于1. 二叉树的应用是为了弥补链表的查询效率问题,但是极端情况下,二叉搜索树会无限接近 ...
- [算法] 数据结构之AVL树
1 .基本概念 AVL树的复杂程度真是比二叉搜索树高了整整一个数量级——它的原理并不难弄懂,但要把它用代码实现出来还真的有点费脑筋.下面我们来看看: 1.1 AVL树是什么? AVL树本质上还是一棵 ...
- AVL树的算法思路整理
http://www.cnblogs.com/heqile/archive/2011/11/28/2265713.html 看完了<数据结构与算法分析(C++描述)>的4.4节AVL树,做 ...
- 红黑树和AVL树的实现与比较-----算法导论
一.问题描述 实现3种树中的两种:红黑树,AVL树,Treap树 二.算法原理 (1)红黑树 红黑树是一种二叉查找树,但在每个结点上增加一个存储位表示结点的颜色,可以是red或black.红黑树满足以 ...
随机推荐
- Centos下 Nginx安装与配置
网上找了好多资料.都很难找全,这里以这个目录为主,进行备注. Nginx是一款轻量级的网页服务器.反向代理服务器.相较于Apache.lighttpd具有占有内存少,稳定性高等优势.它最常的用途是提供 ...
- Apache 与tomcat区别
Apache与Tomcat有什么关系和区别 经常在用apache和tomcat等这些服务器,可是总感觉还是不清楚他们之间有什么关系,在用tomcat的时候总出现apache,总感到迷惑,到底谁是主谁是 ...
- Concepts and Tricks In CNN
转自:http://blog.cvmarcher.com/posts/2015/05/17/cnn-trick/ 这篇文章主要讲一下Convolutional Neural Network(CNN)里 ...
- sinaBlog中小知识总结
1.上拉刷新的时候记得移除老的数据(同样应用于其他地方) if (vc.currentPage == 1) { //上拉加载 记得移除新的 [vc.totalArr removeAllObjects] ...
- 收缩sql server数据库日志
项目中,可能数据库(sql server数据库)日志太多,占了很多磁盘空间,可以通过收缩数据库日志,减少日志文件大小. 下面以Northwind数据库为例: 1.把数据库的恢复模式设置为“简单模式”: ...
- \t 的理解
在同一个缓冲区内横向跳8个空格. 如果在 \t 前面有字符串,则包括 \t之前出现的字符串之内一共是8个空格.
- 快学Scala-第六章 对象
知识点: 1.单例对象 使用object语法结构达到静态方法和静态字段的目的,如下例,对象定义某个类的单个实例,包含想要的特性,对象的构造器在该对象第一次被使用时调用. object Account{ ...
- pycharm快捷键、常用设置、配置管理
http://blog.csdn.net/pipisorry/article/details/39909057 pycharm学习技巧 Learning tips /pythoncharm/help/ ...
- JS里的CSS函数
<title>无标题文档</title> <script> function css(obj,name,value){ if(arguments.length==2 ...
- java 子类与父类继承关系
People.java public class People { int age,leg = 2,hand = 2; protected void showPeopleMess() { System ...