AVL树实现

最新推荐文章于 2023-01-21 09:17:13 发布
最新推荐文章于 2023-01-21 09:17:13 发布
阅读量1.1k 收藏
点赞数
分类专栏： 数据结构 C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinghongduo/article/details/12713795
版权

AVL树是经典的数据结构，它的操作效率很高，一般情况下与红黑树性能相当，而且实现起来没有红黑树繁琐。以前数据结构课上听老师讲过，但没注意听可怜。而最近我在写一个数据库的数据字典部分恰好用到了AVL树，自己把每种情况都推导了一遍，下面是我封装的avl树，可以用于高效存储key/value键值对。

 

avl.h

#ifndef avl_tree_h
#define avl_tree_h


typedef struct tree_node_t tree_node;

struct tree_node_t {
	tree_node_t *left ,*right;
    struct {
        void *key;
        void *value;
    }kv;
	int height;
	int lccount;
	int rccount;
};

typedef int(*AVL_KEY_CMP)(void*,void*);
typedef void (*AVL_KEY_FREE)(void*,void*);

typedef struct avl_tree AVL_TREE;

struct avl_tree {
    tree_node *root;
    int key_num;
    AVL_KEY_CMP cmp_func;
    AVL_KEY_FREE kv_free;
};

void avl_tree_create(AVL_TREE *tree ,AVL_KEY_CMP cmp ,AVL_KEY_FREE fre);

void avl_tree_free(AVL_TREE *tree);

void avl_tree_insert(AVL_TREE *tree ,void *key ,void *value);

void avl_tree_delete(AVL_TREE *tree ,void *key);

void *avl_tree_search_key(AVL_TREE *tree ,void *key);

tree_node *avl_tree_rank(tree_node *root ,int k);

#define _SWAP_(a,b,type) \
    do { \
    type _t; \
    _t = a; \
    a = b; \
    b = _t; }while(0)


#endif


avl.cc

#include <stdio.h>
#include <time.h>
#include <windows.h>
#include <assert.h>
#include "avl.h"


/*--------------------------------------------------
AVL树实现
树中不允许出现重复关键字

插入,删除,查询,查找第k小的时间复杂度
都为O(log(n))

http://blog.csdn.net/xinghongduo
----------------------------------------------------*/


/*----------------------------
获得一个avl树节点
------------------------------*/
static inline tree_node *avl_tree_node_with_key(void *key ,void *value)
{
	tree_node *n = (tree_node*)malloc(sizeof(tree_node));
    n->kv.key = key;
    n->kv.value = value;
	n->height = 1;
	n->lccount = 0;
	n->rccount = 0;
	n->left = n->right = NULL;
	return n;
}


/*-------------------------------
计算node结点的高度
---------------------------------*/
inline
int avl_tree_get_node_height(tree_node *node)
{
	int m = 0;
	if(NULL == node)
		return 0;

	if(node->left && node->left->height > m) {
		m = node->left->height;
	}

	if(node->right && node->right->height > m) {
		m = node->right->height;
	}
	return m+1;
}


/*-----------------------------------------
以node为根的子树节点数量
-------------------------------------------*/
inline
int avl_tree_node_get_child_count(tree_node *node)
{
	int a = 1;

	if(NULL == node)
		return 0;

	if(NULL != node->left) {
		a += node->left->lccount + node->left->rccount + 1;
	}

	if(NULL != node->right) {
		a += node->right->lccount + node->right->rccount + 1;
	}

	return a;
}

/*------------------------
更新节点信息
--------------------------*/
inline
void avl_tree_node_update(tree_node *node)
{
	node->height = avl_tree_get_node_height(node);
	node->lccount = avl_tree_node_get_child_count(node->left);
	node->rccount = avl_tree_node_get_child_count(node->right);
}


/*
调整平衡
*/
static inline tree_node *avl_tree_make_balance(tree_node *root)
{
	int balance ,lh ,rh;
	tree_node *lc ,*rc ,*t;

	lh = avl_tree_get_node_height(root->left);
	rh = avl_tree_get_node_height(root->right);
	balance = lh - rh;

	if(2 == balance) {

		lc = root->left;
		rc = root->right;

		if(avl_tree_get_node_height(root->left->left) > 
			avl_tree_get_node_height(root->left->right)) {
			root->left = lc->right;
			lc->right = root;
			root = lc;

			avl_tree_node_update(root->right);

		} else {
			t = lc->right;
			root->left = t->right;
			lc->right = t->left;
			t->right = root;
			t->left = lc;
			root = t;

			avl_tree_node_update(lc);
			avl_tree_node_update(root->right);
		}

	} else if(-2 == balance) {

		lc = root->left;
		rc = root->right;

		if(avl_tree_get_node_height(root->right->left) > 
			avl_tree_get_node_height(root->right->right)) {
			t = rc->left;
			root->right = t->left;
			rc->left = t->right;
			t->left = root;
			t->right = rc;
			root = t;

			avl_tree_node_update(root->left);
			avl_tree_node_update(root->right);
		} else {
			root->right = rc->left;
			rc->left = root;
			root = rc;

			avl_tree_node_update(root->left);
		}
	}

	avl_tree_node_update(root);
	return root;
}

/*------------------------------------
向avl树中插入一个结点
--------------------------------------*/
static tree_node *avl_tree_insert_(AVL_TREE *tree ,tree_node *root ,tree_node *ins)
{
    int cmp_res;
	tree_node **p;

    assert(tree && ins && 
        tree->cmp_func && tree->kv_free);

	if(NULL == root) {
        tree->key_num++;
		return ins;
	}

	p = &root->left;

    cmp_res = tree->cmp_func(ins->kv.key ,root->kv.key);

	if(0 == cmp_res) {
		/*插入了重复的关键字*/
        tree->kv_free(ins->kv.key ,ins->kv.value);
        free(ins);
        assert(0);
		return root;
	}
	if(0 < cmp_res) {
		p = &root->right;
	}

	if(NULL == *p) {
		*p = ins;
        tree->key_num++;
	} else {
		*p = avl_tree_insert_(tree ,*p ,ins);
	}

	root = avl_tree_make_balance(root);
	return root;
}


tree_node *avl_tree_get_max_key(tree_node *root)
{
	tree_node *p = root;

	while(NULL != p->right) {
		p = p->right;
	}
	return p;
}

tree_node *avl_tree_get_min_key(tree_node *root)
{
	tree_node *p = root;

	while(NULL != p->left) {
		p = p->left;
	}
	return p;
}

/*--------------------------------------
在avl树中删除一个关键字
----------------------------------------*/
static tree_node *avl_tree_delete_(AVL_TREE *tree ,tree_node *root ,void *key)
{
    int cmp_res;
	tree_node *t ,**p;

    if(NULL == root) return NULL;

	p = &root->left;

    cmp_res = tree->cmp_func(key ,root->kv.key);

	if(0 == cmp_res) {

		if(NULL == root->left && NULL == root->right) {
			/*删到了叶节点*/
            tree->kv_free(root->kv.key ,root->kv.value);
			free(root);
            tree->key_num--;
			return NULL;
		}

		if(avl_tree_get_node_height(root->left) >= 
			avl_tree_get_node_height(root->right)) {
			t = avl_tree_get_max_key(root->left);
		} else {
			t = avl_tree_get_min_key(root->right);
			p = &root->right;
		}

        _SWAP_(root->kv.key ,t->kv.key ,void*);
        _SWAP_(root->kv.value ,t->kv.value ,void*);

	} else {

		if(0 < cmp_res) {
			p = &root->right;
		}
	}

	*p = avl_tree_delete_(tree ,*p ,key);
	root = avl_tree_make_balance(root);
	return root;
}


/*
释放avl树的每个结点
*/
static void avl_tree_free_(AVL_TREE *tree ,tree_node *root)
{
    if(NULL == root) return;

    if(NULL != root->left) {
        avl_tree_free_(tree ,root->left);
    }
    if(NULL != root->right) {
        avl_tree_free_(tree ,root->right);
    }
    tree->kv_free(root->kv.key ,root->kv.value);
    free(root);
}

/*--------------------------------
建立空的avl树
----------------------------------*/
void avl_tree_create(AVL_TREE *tree ,AVL_KEY_CMP cmp ,AVL_KEY_FREE fre)
{
    assert(tree && cmp && fre);
    tree->root = NULL;
    tree->cmp_func = cmp;
    tree->kv_free = fre;
    tree->key_num = 0;
}

/*---------------------------------
释放avl树
----------------------------------*/
void avl_tree_free(AVL_TREE *tree)
{
    assert(tree);
    avl_tree_free_(tree ,tree->root);
    tree->root = NULL;
    tree->key_num = 0;
    tree->kv_free = NULL;
    tree->cmp_func = NULL;
}

/*---------------------------------------
在AVL树中插入一个键值对
-----------------------------------------*/
void avl_tree_insert(AVL_TREE *tree ,void *key ,void *value)
{
    tree_node *ins = avl_tree_node_with_key(key ,value);
    tree->root = avl_tree_insert_(tree ,tree->root ,ins);
}

/*-------------------------------------
在AVL树中删除一个键值对
---------------------------------------*/
void avl_tree_delete(AVL_TREE *tree ,void *key)
{
    tree->root = avl_tree_delete_(tree ,tree->root ,key);
}

/*-------------------------------------
在AVL树中查找关键字
返回key对应的value
--------------------------------------*/
void *avl_tree_search_key(AVL_TREE *tree ,void *key)
{
    int cmp_res;
    tree_node *p = tree->root;

    assert(tree->cmp_func);

	while(NULL != p) {
        cmp_res = tree->cmp_func(key ,p->kv.key);
		if(0 == cmp_res) {
            return p->kv.value;
		}

		if(0 > cmp_res) {
			p = p->left;
		} else {
			p = p->right;
		}
	}
	return NULL;
}

/*
中序遍历
*/
void walk_tree(tree_node *root)
{
	if(NULL == root) return;
	
	if(NULL != root->left)
		walk_tree(root->left);
	printf("%d " ,(int)root->kv.key);
	if(NULL != root->right)
		walk_tree(root->right);
}

/*--------------------------------
返回第k大个节点
---------------------------------*/
tree_node *avl_tree_rank(tree_node *root ,int k)
{
	int lcn = 0;
	if(NULL == root)
		return NULL;

	if(NULL != root->left) {
		lcn = root->lccount;
	}

	if(1 == k-lcn) {
		return root;
	} else if(1 < k-lcn) {
		return avl_tree_rank(root->right ,k-lcn-1);
	}
	return avl_tree_rank(root->left ,k);
}

int cmp(void *a ,void *b)
{
    int ta = (int)a;
    int tb = (int)b;
    if(a < b) return -1;
    else if(a == b) return 0;
    return 1;
}

void mfree(void *key ,void *value)
{

}

int main()
{
	int i ,t;
    AVL_TREE avl;
    
    avl_tree_create(&avl ,cmp ,mfree);

	t = clock();
	for(i = 1;i <= 10000000 ;i ++) {
		avl_tree_insert(&avl ,(void*)i ,(void*)i);
	}

	for(i = 1;i <= 10000000 ;i ++) {
		if(NULL == avl_tree_search_key(&avl ,(void*)i)){
			puts("error!");
			break;
		}
	}

	for(i = 1 ;i <= 10000000;i ++) {
		avl_tree_delete(&avl ,(void*)i);
	}

	printf("%d\n" ,clock()-t);
    avl_tree_free(&avl);
    return 0;
}


 

施工中请绕行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
avl树实现hash表
12-29
利用avl树实现hash表，自测通过。下载代码直接编译，即可运行。
AVL树的实现（图文详解）
AllenSquirrel
05-19 4131
AVL树的实现
手把手教你实现AVL树、平衡二叉树
weixin_61857742的博客
04-07 1371
今天，小编带大家一起来学习平衡二叉树（AVL树）吧。以下就简称AVL树了。 想必能点开这篇博客的朋友都是极度深爱计算机的，那今天就让我们一起揭开AVL树的神秘面纱吧！ 目录 一.基本概念 二.实现原理 （一）插入左子树 ①插入左子节点 ②插入右子节点 （二）插入右子树 ①插入右子节点 ②插入左子节点 （三）左旋转 （四）右旋转 三.代码实现 一.基本概念 AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis。 AVL树是搜索二叉树的一
史上最详细的AVL树的实现(万字+动图讲解旋转)
Lin5200000的博客
01-21 1787
一篇文章教你深入理解AVL树，以及AVL树的插入实现
AVL树详解（两种实现）
Lidystar的博客
11-10 546
AVL树是最先发明的自平衡二叉查找树（简称平衡二叉树），它的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。
数据结构(C++) : AVL树 实现篇
weixin_57761086的博客
10-08 2829
在二叉搜索树的基础上学习AVL树，通过大量图片学习AVL树的重点：左单旋，右单旋，左右双旋，右左双旋。同时写出验证函数，验证是否是AVL树
C++平衡Avl树实现.zip
08-20
C++平衡树实现
基于Qt和Avl树实现登录系统【100013012】
最新发布
07-19
用Qt制作的登录系统,使用Avl树实现增删改查,UI界面仅有登录系统。
AVLTrees:Java中的AVL树实现
05-05
AVL树Java中的AVL树实现有两个基本操作，使用这些操作树本身会保持平衡。 左旋转。 右旋。 然后将有四种可能性左-左情况：— x是y的左子代，y是z的左子代。 左右案例：— x是y的右子代，y是z的左子代。 左右案例：—...
数据结构avl树实现
03-18
avl树实现 数据结构数据结构数据结构数据结构
史上最详细的AVL树（含代码实现）
热门推荐
qq_56999918的博客
02-01 1万+
1.AVL树的相关概念 二叉搜索树在一定程度上可以提高搜索效率，但是当序列是有序时：如果所示 此时二叉搜索树退化成单链表，搜索效率退化为O（N)。为了解决这个问题科学家引入了AVL树，又称平衡搜索二叉树 AVL简称平衡二叉树。由前苏联的数学家 Adelse-Velskil 和Landis 在 1962 年提出的高度平衡的二叉树，根据科学家的英文名也称为 AVL 树。它具有如下几个性质： 可以是空树。 假如不是空树，任何一个结点的左子树与右子树都是平衡二叉树，并且高度之差的绝值不超过...
AVL树的详解与实现
smx_dd的博客
01-21 1396
之前详细讲解过了二叉搜索树（二叉搜索树详解博客链接：https://blog.csdn.net/smx_dd/article/details/86563142），但是二叉搜索树有缺陷，那就是当插入数据有序时，会退化成单支树，查找效率相当于一个链表。为了解决上述问题，有这样一种办法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降...
POJ2985 The k-th Largest Group(平衡树查询第K大)
weixin_34167819的博客
11-22 130
传送门 平衡树查询第k大的裸题，用并查集来维护一下哪些猫是一组的就可以了。查询第k大要维护size域，保存一个节点下面的字数的大小，更新的时候从下边更新。 #include<cstdio> #define MAXN 200005 struct SBT { int v, sz, ch[2], cnt; } t[MAXN]; int n, m, cnt,...
【C++】AVL树的完整实现
ly_6699的博客
05-04 2445
#define _CRT_SECURE_NO_WARNINGS 1 #pragma once #include <stdlib.h> #include <iostream> #include <assert.h> using namespace std; namespace LY { template <class K, class V> ...
排名树RankTree
Likes的博客
04-24 1169
在所有的平衡树（AVL、红黑树、Treap......）都可以做成RankTree。RankTree主要在平衡树的基础上多支持两个功能： Kth(k)：查找第k小的元素 Rank(x)：x的名次，即x是第几小的元素 如上两个函数都可以在O(logN)的复杂度里完成 为此Node结构体需要改进（加入了s字段）： struct Node // Rank Tree结点的定义 { Nod...
AVL树的实现
丁香枝上，豆蔻梢头
06-10 780
AVL树又名高度平衡的搜索二叉树，上一篇文章我们讲到二叉搜索树时，说到它存在一个问题：退化，这使得它的时间复杂度从O（lgN）降到了O（N）。为了解决这个问题，出现了一棵新的树，也就是AVLtree，我们先来看看它的性质： 1,它是一棵搜索 二叉树，所以满足每个节点的值大于左子树中任意节点的值，并且小于右子树中任意节点的值。 2,它是一棵平衡树，他要求每个节点的左右子树的深度之差不能超过1，即这
AVL树的原理及代码实现
qq_39747794的博客
11-02 1140
前言 如果你还没有学习过二叉查找树，那么请你先去看看二叉查找树，因为AVL树便是从二叉查找树进化而来的，不看的话你无法理解AVL树。 链接：二叉查找树的原理及实现 如果你已经学习了二叉查找树，你会觉得二叉查找树性能在各方面都很好，就只有一丢丢的小毛病，那就是当数据非常坑时，二叉查找树退化成了一条单链表，这样各种操作的时间复杂度都变为O(n)了，怎么办呢，今天所要学习的AVL树便以其惊艳四座的...
AVL树
Sunnylunch-blog
10-26 1590
AVL树又称作高度平衡二叉树，它实际上是一种优化了的搜索二叉树。我们知道，由于二叉搜索树存在缺陷，有可能会退化成单链表，这样的话搜索的效率就降低了。为了将二叉搜索树的效率控制在O(logN)的级别，所以我们要给二叉搜索树加上一些条件，使得二叉搜索树高度平衡，时间复杂度为O(logN)。 概念： 1、首先AVL树是一颗二叉搜索树。 2、其次它的左子树和右子树都是AVL树。 3、它的左
python 用AVL树实现字典类型
05-17
AVL树是一种自平衡二叉搜索树，可以用来实现字典类型。在实现字典类型时，我们可以将键值对存储在AVL树的节点中，其中键作为节点的关键字，值则作为节点的附加数据。 下面是一个简单的AVL树实现字典类型的Python代码： ```python class AVLNode: def __init__(self, key, val): self.key = key self.val = val self.left = None self.right = None self.height = 1 class AVLTree: def __init__(self): self.root = None def insert(self, key, val): self.root = self._insert(self.root, key, val) def _insert(self, node, key, val): if not node: return AVLNode(key, val) if key < node.key: node.left = self._insert(node.left, key, val) elif key > node.key: node.right = self._insert(node.right, key, val) else: node.val = val node.height = 1 + max(self._height(node.left), self._height(node.right)) balance = self._get_balance(node) if balance > 1 and key < node.left.key: return self._right_rotate(node) if balance < -1 and key > node.right.key: return self._left_rotate(node) if balance > 1 and key > node.left.key: node.left = self._left_rotate(node.left) return self._right_rotate(node) if balance < -1 and key < node.right.key: node.right = self._right_rotate(node.right) return self._left_rotate(node) return node def search(self, key): node = self._search(self.root, key) if node: return node.val else: return None def _search(self, node, key): if not node: return None if key == node.key: return node if key < node.key: return self._search(node.left, key) else: return self._search(node.right, key) def _height(self, node): if not node: return 0 return node.height def _get_balance(self, node): if not node: return 0 return self._height(node.left) - self._height(node.right) def _left_rotate(self, node): new_root = node.right node.right = new_root.left new_root.left = node node.height = 1 + max(self._height(node.left), self._height(node.right)) new_root.height = 1 + max(self._height(new_root.left), self._height(new_root.right)) return new_root def _right_rotate(self, node): new_root = node.left node.left = new_root.right new_root.right = node node.height = 1 + max(self._height(node.left), self._height(node.right)) new_root.height = 1 + max(self._height(new_root.left), self._height(new_root.right)) return new_root ``` 在这个实现中，我们定义了AVLNode类来表示AVL树的节点。每个节点包含一个键、一个值、左右子树指针以及节点高度。AVLTree类是AVL树的实现，包含了插入、搜索、左旋和右旋等基本操作。 在insert操作中，我们首先按照二叉搜索树的规则找到要插入的位置。然后更新节点高度，并计算平衡因子。如果平衡因子超过了1或-1，我们就需要进行旋转来保持AVL树的平衡。 在search操作中，我们按照二叉搜索树的规则搜索键值对应的节点，并返回其值。 这个AVL树实现可以用来实现字典类型。我们可以将键值对存储在AVL树的节点中，并通过搜索操作来查找键对应的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值