AVL树C语言实现

最新推荐文章于 2024-02-02 15:46:24 发布
最新推荐文章于 2024-02-02 15:46:24 发布
阅读量638 收藏 1
点赞数
分类专栏： 数据结构与算法分析学习笔记 文章标签： c语言 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shayabean_/article/details/45875323
版权 
#ifndef AVLTREE_H_
#define AVLTREE_H_

#define FLOWOVER -1

struct AVLTreeADT;
typedef struct AVLTreeADT * AVLTree;//根指针,与节点指针本质一样
typedef struct AVLTreeADT * AVLNode;//节点指针
typedef int ElemType;//数据域数据类型

struct AVLTreeADT{
	ElemType elem;//数据域
	AVLTree left;//树节点左儿子指针
	AVLTree right;//树节点右儿子指针
	int height;//当前节点的高度,空节点为-1,只有本身的节点的高度为0
};

//辅助函数,返回输入节点的高度
static int Height(AVLNode N);
//辅助函数,返回输入两高度值中大的那一个
static int Max(int height_1, int height_2);
//辅助函数,有左儿子的单旋转,对N的左儿子的左子树进行一次插入后调用
static AVLNode SingleRotateWithLeft(AVLNode N);
//辅助函数,有右儿子的单旋转,对N的右儿子的右子树进行一次插入后调用
static AVLNode SingleRotateWithRight(AVLNode N);
//辅助函数,有左儿子的双旋转,对N的左儿子的右子树进行一次插入后调用
static AVLNode DoubleRotateWithLeft(AVLNode N);
//辅助函数,有右儿子的双旋转,对N的右儿子的左子树进行一次插入后调用
static AVLNode DoubleRotateWithRight(AVLNode N);
//清空树，返回根指针
AVLTree MakeEmpty(AVLTree T);
//在树中查找是否存在E,找到则返回true
bool Find(ElemType E, AVLTree T);
//查找树中的最小值,返回,若为空树,返回-1
ElemType FindMin(AVLTree T);
//查找树中的最大值,返回,若为空树,返回-1
ElemType FindMax(AVLTree T);
//向树T中插入E,返回根地址
AVLTree Insert(ElemType E, AVLTree T);
//从树T中删除E,返回根地址
AVLTree Delete(ElemType E, AVLTree T);
//检索,输入节点指针,返回该节点对应的节点的数据域
ElemType Retrieve(AVLNode N);
//中序遍历树B并打印,值域为空则输出0
void PrintTree(AVLTree T);

#endif


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

static int Height(AVLNode N)
{//static表示函数可见性仅为定义文件
	if (N == NULL){
		return -1;
	}
	else{
		return N->height;
	}
}

static int Max(int height_1, int height_2)
{
	if (height_1 > height_2){
		return height_1;
	}
	else{
		return height_2;
	}
}

static AVLNode SingleRotateWithLeft(AVLNode N)
{//图见课本P82、P88,结合图画一遍基本就能理解原理了
	AVLNode leftSonOfN;
	leftSonOfN = N->left;
	N->left = leftSonOfN->right;
	leftSonOfN->right = N;

	N->height = Max(Height(N->left), Height(N->right));//重置节点深度
	leftSonOfN->height = Max(Height(leftSonOfN->left), Height(leftSonOfN->right));

	return leftSonOfN;
}

static AVLNode SingleRotateWithRight(AVLNode N)
{//图见课本P82、P88
	AVLNode rightSonOfN;
	rightSonOfN = N->right;
	N->right = rightSonOfN->left;
	rightSonOfN->left = N;

	N->height = Max(Height(N->left), Height(N->right));//重置节点深度
	rightSonOfN->height = Max(Height(rightSonOfN->left), Height(rightSonOfN->right));

	return rightSonOfN;//返回新的树根
}

static AVLNode DoubleRotateWithLeft(AVLNode N)
{//图见课本P84、P89
	N->left = SingleRotateWithRight(N->left); //以N->left为节点完成第一次单右旋转
	return SingleRotateWithLeft(N); //以N为节点完成第二次单左旋转,并返回根节点
}

static AVLNode DoubleRotateWithRight(AVLNode N)
{//图见课本P84、P89
	N->right = SingleRotateWithLeft(N->right);
	return SingleRotateWithRight(N);
}

AVLTree MakeEmpty(AVLTree T)
{//唯一根节点T = NULL表示树为空
	if (T != NULL){
		MakeEmpty(T->left);
		MakeEmpty(T->right);
		free(T);
	}
	return NULL;
}

ElemType FindMin(AVLTree T)
{
	if (T != NULL){
		if (T->left == NULL){
			return T->elem;
		}
		else{
			return FindMin(T->left);//递归查找左子树的左子树，最小值一定在最左边  
		}
	}
	return -1;//树为空，返回-1  
}

ElemType FindMax(AVLTree T)
{
	if (T != NULL){
		if (T->left == NULL){
			return T->elem;
		}
		else{
			return FindMax(T->right);//递归查找右子树的右子树，最大值一定在最右边  
		}
	}
	return -1;//树为空，返回-1  
}

AVLTree Insert(ElemType E, AVLTree T)
{
	if (T == NULL){
		T = (AVLTree)malloc(sizeof(struct AVLTreeADT));
		if (T == NULL)
			exit(FLOWOVER);
		else{
			T->elem = E;
			T->left = NULL;
			T->right = NULL;
		}
	}

	else if (E < T->elem){
		T->left = Insert(E, T->left);//往左边插入,深度增加的必为左边
		if (Height(T->left) - Height(T->right) == 2){
			if (E < T->left->elem){
				T = SingleRotateWithLeft(T);
			}
			else{
				T = DoubleRotateWithLeft(T);
			}
		}
	}

	else if (E > T->elem){
		T->right = Insert(E, T->right);
		if (Height(T->right) - Height(T->left) == 2){
			if (E > T->right->elem){
				T = SingleRotateWithRight(T);
			}
			else{
				T = DoubleRotateWithRight(T);
			}
		}
	}

	else{//重复插入,不做任何操作,直接返回
		return T;
	}

	T->height = Max(Height(T->left), Height(T->right));//每次递归回退后更新节点高度
	return T;
}

AVLTree Delete(ElemType E, AVLTree T)
{//删除的点可能不属于需要旋转的树,如何处理
	if (T != NULL){//判断是否为空树
		if (T->elem == E){//如果找到了
			if (T->left == NULL || T->right == NULL){//没有子节点或只有一个子节点
				AVLNode tempPtr = T;
				if (T->right == NULL){//没有子节点或只有左节点
					T = T->left;
					free(tempPtr);
				}
				else if (T->left == NULL){//只有右节点
					T = T->right;
					free(tempPtr);
				}
			}

			else{//有两个儿子,用其右子树中最小的数据代替该节点的数据,然后递归删除
				T->elem = FindMin(T->right);
				T->right = Delete(T->elem, T->right);//相当于用右子树中最小的节点覆盖删除节点,然后删除右子树中的那个节点
			}
		}

		else if (E < T->elem){//如果没找到,继续搜索左子树
			T->left = Delete(E, T->left);
			T->height = Max(Height(T->left), Height(T->right));//每次递归回退后更新节点高度
			if (Height(T->right) - Height(T->left) == 2){//若两子树高度差为2,则通过旋转修复
				if (Height(T->right->left) > Height(T->right->right)){//通过子树的左右子树深度判断需要采用哪种修复方式
					T = DoubleRotateWithRight(T);
				}
				else if (Height(T->right->left) < Height(T->right->right)){
					T = SingleRotateWithRight(T);
				}
				else{//当子树的左右子树深度相同时,有可能会导致一次修复还不够,需要补充修复一次,具体自己画图可知
					T = DoubleRotateWithRight(T);
					if (Height(T->right->right) - Height(T->right->left) == 2){
						T->right = SingleRotateWithRight(T->right);
					}
				}
			}
		}

		else{//如果没找到,继续搜索右子树
			T->right = Delete(E, T->right);
			T->height = Max(Height(T->left), Height(T->right));//每次递归回退后更新节点高度
			if (Height(T->left) - Height(T->right) == 2){
				if (Height(T->left->left) > Height(T->left->right)){
					T = SingleRotateWithLeft(T);
				}
				else if (Height(T->left->left) < Height(T->left->right)){
					T = DoubleRotateWithLeft(T);
				}
				else{
					T = DoubleRotateWithLeft(T);
					if (Height(T->left->left) - Height(T->left->right) == 2){
						T->left = SingleRotateWithLeft(T->left);
					}
				}
			}
		}
	}

	else{//空树,不做任何操作,直接回退
		return T;
	}


	return T;
}

ElemType Retrieve(AVLNode N)
{
	if (N != NULL){
		return N->elem;
	}
	else
		return -1;
}

void PrintTree(AVLTree T)
{
	if (T == NULL){
		printf("0 ");
	}
	else{
		PrintTree(T->left);
		printf("%d ", T->elem);
		PrintTree(T->right);
	}
}




#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "AVLTree.h"

int main(){
	srand((int)time(0));
	AVLTree testTree = NULL;

	while (1){

		int a[20];//生成20个随机数存入树中
		for (int i = 0; i < 20; i++){
			int flag = 1;
			a[i] = rand() % 100 + 1;
			while (flag != 0 && i != 0){
				for (int k = 0; k < i; k++){
					if (a[k] == a[i]){
						a[i] = rand() % 100 + 1;
						break;
					}
					if (k == i - 1){
						flag = 0;
					}
				}
			}
			testTree = Insert(a[i], testTree);
		}

		printf("testTree初始化为:");
		PrintTree(testTree);
		printf("\n");

		int b[10];//生成十个不同的随机数,作为a[20]的下标
		for (int i = 0; i < 10; i++){
			b[i] = rand() % 20;
			int flag = 1;
			while (flag != 0 && i != 0){
				for (int k = 0; k < i; k++){
					if (b[k] == b[i]){
						b[i] = rand() % 20;
						break;
					}
					if (k == i - 1){
						flag = 0;
					}
				}
			}
		}

		for (int i = 0; i < 10; i++){//随机删除十个数,每删除一个打印一次
			testTree = Delete(a[b[i]], testTree);
			printf("删除%d后,testTree为:", a[b[i]]);
			PrintTree(testTree);
			printf("\n");
		}

		testTree = MakeEmpty(testTree);

		system("pause");
	}
}



Shayabean_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL树及C语言实现
IT_Linux
03-28 9355
概念   平衡二叉树(Balanced binary tree)是由苏联数学家Adelson-Velskii and Landis于1962年首先提出的，所以又称为AVL树。 定义：平衡二叉树或为空树,或满足如下性质的二叉树:  （1）本身首先是一棵二叉搜索树   （2）左右子树深度之差的绝对值不超过1;   （3）左右子树仍然为平衡二叉树. 平衡因子BF=左子树深度－右子树深度.
AVL Tree C语言实现
andy的专栏
10-09 655
#ifndef _AVLTree_H struct Avlnode; typedef struct Avlnode *Position; typedef struct Avlnode *Avltree; Avltree MakeEmpty(Avltree t); Position Find(int x,Avltree t); Position FindMin(Avltree t); Posit
平衡二叉排序树之AVL树（C语言实现）
zhao_Tao_WA的博客
07-01 663
本文详细介绍了平衡二叉排序树中的AVL树，对失衡类型和不同失衡类型的调整方式做了细致的描写，并用C语言实现了AVL树
C 语言实现 AVL 树
SauryN的博客
08-30 1666
一、平衡二叉树简介     平衡二叉树又称 AVL树，其具有如下两个性质： 必须是二叉树； 必须是一颗空树或者其左右子树的高度只差不超过 1。     平衡二叉树的实现主要是为了避免普通二叉查找树在极端情况下（全部节点只有左孩子或者全部节点只有右孩子）会像链表那样影响性能。 二、AVL树 自平衡 #include <stdio.h> #include <stdlib.h> #include <string.h> #include "AVLTree.h" #defi
C语言-AVL树
2301_79349959的博客
02-02 799
当插入节点在“外侧”时（即左-左或右-右的情况），进行所谓的单旋转操作。在保留二叉搜索树特性的同时，又加上了平衡条件，即每个节点的左右子树的高度最多差1。《数据结构与算法分析》一书中认为AVL树的删除操作较为复杂，更加推荐使用懒惰删除，即保留节点在树中，但是加以标记。不过值得注意的是，代码中的Height函数单独出来写是有必要的，因为我们要处理空树的情况。总体上插入函数的思路与二叉搜索树的插入函数思路相似，不过多了对树高导致不平衡的条件的讨论。在有了以上对旋转的讨论之后，完成节点的插入操作就不再是难事。
AVL树（C语言实现）
mayfly_strive的博客
02-09 2335
AVL树的相关操作，包括插入，删除，查找，调整。（C语言实现）
AVL树的实现(C语言实现)
rainxbow的专栏
02-15 962
最近恶补数据结构，不过抱着小侄女实在复习不进去。。。这才复习完树 当时对于平衡树就没有一个系统的了解  具体的感念就不贴了，仔细说一说如何调整平衡二叉树 如果插入破坏了原有的平衡，“麻烦结点”在发现者右子树的右边，因而叫 RR 插入，需要RR 旋转（右单旋） 做如下调整 “麻烦结点”在发现者左子树的左边，因而叫 LL 插入，需要LL 旋转（左单旋）
AVL树的C语言实现
11-30
AVL树是一种自平衡二叉查找树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。...AVL树的C语言实现涉及到的数据结构和算法原理深入而有趣，适合对数据结构有深入理解的程序员进行实践。
AVL平衡树及插入操作的C语言实现
06-21
2. **C语言实现AVL树** - **数据结构**：首先，我们需要定义一个结构体来表示AVL树节点，包含键值、平衡因子、左子树和右子树的指针。 - **初始化**：创建空AVL树，通常用NULL表示。 - **查找操作**：从根节点...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种...
基于C语言实现哈夫曼树.zip
最新发布
05-10
例如，使用自平衡二叉查找树（如AVL树或红黑树）作为优先队列，可以简化哈夫曼树构建过程。 以上就是基于C语言实现哈夫曼树的基本思路和关键步骤。在实践中，还需要处理各种边界情况，如处理空文本、处理非ASCII...
若干平衡树的C语言实现_C语言_平衡树_
09-29
在C语言中实现平衡树，通常会涉及到AVL树、红黑树或者Treap等经典的数据结构。 **AVL树** AVL树是最先被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名。AVL树的关键特性是...
AVL树(C语言)
yd_xiaocheng的博客
09-30 382
AVL树(C语言)
AVL树（c实现）
u010049696的专栏
03-20 599
最近阅读java的TreeMap源码，发觉是使用红黑树实现内部的数据管理，所以开始学习编写红黑树。然后发现要想理解红黑树还是要从基础的二叉平衡树的开始。于是，最终决定拿AVL树开刀。 网络上有很多AVL树的各种语言实现版本，个人偏爱c的绝对控制性编程，所以选择了c实现。令人庆幸的是，一个非常简易的AVL树c实现被我找到。现在就在其基础上加上个人理解把AVL树实现描述如下：
AVL树的创建--C语言实现
Phyloser的博客
03-08 2168
AVL树是一种自平衡（Self-balancing）二叉查找树（Binary Search Tree），要求任何一个节点的左子树和右子树的高度之差不能超过1。 AVL树的插入操作首先会按照普通二叉查找树的插入操作进行，不同的是在成功插入一个节点后会向上进行回溯，判断路径中的每一个节点左子树和右子树高度之差，如果相差大于1，则进行旋转操作使得树重新达到平衡状态，旋转的本质其实是为当前不平衡的子树选择一
AVL（自平衡二叉树）树的实现（C语言）
c_living的博客
07-23 5165
AVL树是可以在插入、删除节点之后进行自平衡的树，平衡的定义是结点的左子树和右子树的深度差不超过1，也就： | Deep（LeftChild） - Deep（RightChild）| &lt;= 1，整棵树的平衡也就是树的每个结点都是满足上述情况。那么下面我们要解决问题就是当树在插入数据和删除数据的时候，如果树不平衡了我们该怎么办。 上面就是我们在插入或者删除的时候可能导致的树的不平衡的所...
AVL树(三)之 Java的实现
WO的专栏
03-30 964
概要 前面分别介绍了AVL树"C语言版本"和"C++版本"，本章介绍AVL树的Java实现版本，它的算法与C语言和C++版本一样。内容包括： 1. AVL树的介绍 2. AVL树的Java实现 3. AVL树的Java测试程序 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3577479.html   更多内容: 数据结构与算法系列 目录
基数排序单链表实现(C语言)
Shayabean->MyBlog
04-05 3940
头文件： /*基数排序，单链表实现*/ #ifndef RADIX_SORT_H #define RADIX_SORT_H #include #define FLOWOVER -1 #define LIST_EMPTY -2 struct RadixSort; typedef struct RadixSort * List; typedef struct RadixSort * Node;
用c语言实现AVL树
05-26
AVL树是一种平衡二叉树，C语言中可以通过结构体和指针来实现AVL树。下面是一个简单的AVL树实现示例，包括AVL树的创建、插入、删除和遍历操作。 ```c #include #include // 定义AVL树节点结构体 struct node { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值