数据结构课程设计——平衡二叉树（有菜单页面，最详细操作）-C

最新推荐文章于 2024-08-08 15:09:52 发布
最新推荐文章于 2024-08-08 15:09:52 发布
阅读量1.6k 收藏 35
点赞数 9
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DongLUOWAN/article/details/115479636
版权

AVL树 平衡二叉树 查找 插入 删除
关键词由CSDN通过智能技术生成

功能要求：
//（1）生成一组随机数并输出。
//（2）利用生成的随机数来建立平衡二叉排序树，并显示。
//（3）分别计算成功和失败的平均查找长度。
//（4）按数值递减次序输出数据。
//（5）功能：检索（输出依次比较的数据）、插入、删除。

不多说，上代码！

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<iostream>
#include<math.h>
int *ptr=NULL,temp;//中序遍历返回建立数组
int *ptr1=NULL,temp1;
typedef int Elementtype;
typedef struct Avltree
{
	Elementtype key;									//关键字大小
	struct Avltree* lchild, * rchild, * parent;			//左右孩子结点和父结点
}avlnode;

void Operation_AVL(avlnode*&node,avlnode*b);            //不平衡后调整的主要方式
avlnode* Insertnode(avlnode*& node,Elementtype k); 		//插入结点,返回该结点
avlnode* Creat_AVL(int*p,int n);				   		//建立AVL树，返回AVL的根结点
void Parent_adjust(avlnode*& bt);				   		//结点父结点指向
int Get_height(avlnode* node);                     		//获取当前结点的深度
//操作
void AVL_ASLsucc(avlnode*node,int m,int &succ);         //查找成功的平均查找长度
void AVL_ASLunsucc(avlnode *node,int t,int &unsucc);    //查找失败的平均查找长度
void Decrease_sort(avlnode *node,int n,int flag);       //递减输出二叉树的数据
void Search_element(avlnode *node,Elementtype e);  		//在二叉树中查找值为e的某元素
void Insert_element(avlnode *&node,Elementtype e); 		//插入某值为e的结点

void Creat_order(avlnode *node,int n,int flag);          //中序遍历结果
avlnode *Inorder(avlnode *node,Elementtype e,int n);    //找到某结点中序遍历的前驱结点,是删除操作的一个工具
avlnode *Search(avlnode*node,Elementtype e);       		//返回前驱结点,是删除操作的一个工具
void Delete_element(avlnode*&snode,avlnode *node,Elementtype e,int n);//删除某值为e的结点

void Print_AVL(avlnode* bt);                       		//打印AVL

int main()
{
	srand((int)time(0));		//种子
	Elementtype e1,e2,e3;       //查找，插入和删除
	int n;      				//随机数的个数
	int *p=NULL;				//存放随机数
	char sign;  				//输入的代号
	avlnode* bt=NULL,*pt=NULL;		    //储存根结点
	int i, j;
 	int succ=0,unsucc=0;       //成功和失败的查找长度
	int m=1,t=1;			   //结点深度
	int flag=0;
	printf("请输入建立平衡二叉树所需要的数据个数：");scanf("%d", &n);
	p = (int* )malloc(n * sizeof(int));
	
	if (p)
	{
		for (i = 0; i < n; i++)
		{
			j = 0; *(p + i) = rand() % 100;
			while (j < i && (*(p + j) != *(p + i) ) )
				j++;
			if (j != i)//有重复就重新对这个元素赋值
				i -= 1;
		}
		printf("这一组随机数是:");
		for (i = 0; i < n; i++)
			printf("%d  ", *(p + i));
		printf("\n");
	}
	printf("建立的二叉树的括号表示法为:");
	bt= Creat_AVL(p,n);//建立二叉树，返回根结点
	Print_AVL(bt);//打印二叉树
	Creat_order(bt,n,flag);
	printf("\n\n");
	
	while(1)
	{
		setbuf(stdin, NULL);//清除输入缓冲区
		printf("			******************平衡二叉树操作表*********************\n");
		printf("			***********《请输入功能的代号来实现相应功能》**************\n");
		printf("			A:计算平衡二叉树成功查找的平均查找长度\n");
        printf("			B:计算平衡二叉树失败查找的平均查找长度\n");
        printf("			C:按数值递减次序输出平衡二叉树中的数据\n");
        printf("			D:查找某个值,若树中存在该值,依次输出所比较数据\n");
        printf("			E:插入一个数据至平衡二叉树中\n");
		printf("			F:删除平衡二叉树中某个结点\n");
        printf("			G:退出\n");
        printf("请输入你的选择->");
        scanf("%c",&sign);
        if(sign=='A'||sign=='B'||sign=='C'||sign=='D'||sign=='E'||sign=='F')
        switch(sign)
        {
        	case 'A':
				AVL_ASLsucc(bt,m,succ);
				if(bt==NULL)
					printf("查找成功的平均查找长度是:%d\n",succ);
				else
					printf("查找成功的平均查找长度是:%d/%d\n",succ+1,n);
				succ=0;
				break;
			case 'B':
				AVL_ASLunsucc(bt,t,unsucc);
					if(bt==NULL)
						printf("查找失败的平均查找长度是:%d\n",unsucc);
					else
						printf("查找失败的平均查找长度是:%d/%d\n",unsucc,n+1);
                    unsucc=0;
                    break;
			case 'C':
				printf("递减输出二叉树的数据:");
				if(ptr!=NULL)
					free(ptr);
   				Decrease_sort(bt,n,flag);
					for(int i=0;i<n;i++)
						printf("%4d",*(ptr+i));
					printf("\n");
					break;
			case 'D':
				printf("请输入需要查找的数据->");scanf("%d",&e1);
				setbuf(stdin, NULL);
				printf("在二叉树中查找元素依次比较的数据是:");
				Search_element(bt,e1);
				break;
			case 'E':
				printf("请输入所要插入的数据->");scanf("%d",&e2);
				setbuf(stdin, NULL);
				Insert_element(bt,e2);
				printf("插入值为%d的结点后,二叉树的括号表示法为:",e2);
				Print_AVL(bt);
				printf("\n");
				n+=1;
				if(ptr1!=NULL)
					free(ptr1);
				Creat_order(bt,n,flag);
				break;
			case 'F':
				printf("请输入所要删除的数据->");scanf("%d",&e3);
				setbuf(stdin, NULL);
				Delete_element(bt,bt,e3,n);
				if(bt==NULL)
					printf("删除操作后,二叉树为空");
				else
				{
					printf("删除操作后，二叉树的括号表示法为:");
					Print_AVL(bt);
				}
				printf("\n");
				n-=1;
				if(ptr1!=NULL)
					free(ptr1);
				Creat_order(bt,n,flag);
				break;
			default:break;
		}
		else if(sign=='G')
		{
			printf("******欢迎下次使用******");
			setbuf(stdin, NULL);
        	break;
        }
		else
		{
			printf("输入错误！请重新输入\n");
			setbuf(stdin, NULL);
		}
	}
	return 0;
}
void Creat_order(avlnode*node,int n,int flag)
{
	if(flag==0)
	{
		temp1=n-1;
		ptr1=(int *)malloc(sizeof(int)*n);
		flag++;
	}
	if(node!=NULL)
	{
		Creat_order(node->lchild,n,flag);
		*(ptr1+temp1)=node->key;
		temp1--;
		Creat_order(node->rchild,n,flag);
	}
}
avlnode* Insertnode(avlnode*& node, Elementtype k)//插入
{
	if (node == NULL)
	{
		node = (avlnode*)malloc(sizeof(avlnode));
		if (node)
		{
			node->key = k;
			node->lchild = NULL; node->rchild = NULL;
			node->parent = NULL;
		}
		return node;
	}
	else if (k < node->key)//小于根结点的值
	{
		return Insertnode(node->lchild, k);
	}
	else//大于根结点的值
	{
		return Insertnode(node->rchild, k);
	}
}
void Parent_adjust(avlnode*& bt)//建立父结点指向，递归
{
	avlnode* p1,*p2;
	if (bt == NULL)//根结点指向NULL
		return;
	p1 = bt->lchild; p2 = bt->rchild;
	if (p1 != NULL && p2 != NULL)
	{
		p1->parent = bt;
		p2->parent = bt;
		Parent_adjust(p1);
		Parent_adjust(p2);
	}
	else if (p1 != NULL && p2 == NULL)
	{
		p1->parent = bt;
		Parent_adjust(p1);
	}
	else if (p1 == NULL && p2 != NULL)
	{
		p2->parent = bt;
		Parent_adjust(p2);
	}
	else
		return;
}
int Get_height(avlnode* node)//返回左右子树的高度差
{
	if (node == NULL)
		return 0;
	else if (node->lchild == NULL && node->rchild == NULL)
		return 1;
	else
		return Get_height(node->lchild) > Get_height(node->rchild) ? (Get_height(node->lchild) + 1) : (Get_height(node->rchild) + 1);
}
avlnode* Creat_AVL(int *p, int n)//建立平衡二叉树
{
	avlnode* bt=NULL,*b=NULL;
	for (int i = 0; i < n; i++)
	{
		b=Insertnode(bt,*(p+i));//插入结点,返回该结点
		Parent_adjust(bt);		//建立父结点指向
		Operation_AVL(bt,b);    //调整平衡二叉树
	}
	return bt;
}
void AVL_ASLsucc(avlnode*node,int m,int &succ)
{
	if(node==NULL)
		return;
	else if(node->lchild!=NULL && node -> rchild!=NULL)//都不空
	{
		m++;
		succ+=2*m;
		AVL_ASLsucc(node->lchild,m,succ);
		AVL_ASLsucc(node->rchild,m,succ);
	}
	//其中一个为空
	else if(node->lchild==NULL&&node->rchild!=NULL || node->lchild!=NULL && node->rchild==NULL)
	{
		m++;
		succ+=m;
		if(node->lchild==NULL)
			AVL_ASLsucc(node->rchild,m,succ);
		else
			AVL_ASLsucc(node->lchild,m,succ);
	}
	//都为空
	else return;
}
void AVL_ASLunsucc(avlnode*node,int t,int &unsucc)
{
	if(node==NULL)
		return;
	else if(node->lchild==NULL&&node->rchild==NULL)//都空
	{
		unsucc+=2*t;
		return;
	}
	//其中一个为空
	else if(node->lchild==NULL&&node->rchild!=NULL || node->lchild!=NULL&&node->rchild==NULL)
	{
		unsucc+=t;
		if(node->lchild==NULL)
		{
			t++;
			AVL_ASLunsucc(node->rchild,t,unsucc);
		}
		else
		{
			t++;
			AVL_ASLunsucc(node->lchild,t,unsucc);
		}
	}
	//都不空
	else
	{
		t++;
		AVL_ASLunsucc(node->lchild,t,unsucc);
		AVL_ASLunsucc(node->rchild,t,unsucc);
	}
}
void Decrease_sort(avlnode*node,int n,int flag)
{
	if(flag==0)
	{
		temp=n-1;
		ptr=(int *)malloc(sizeof(int)*n);
		flag++;
	}
	if(node!=NULL)
	{
		Decrease_sort(node->lchild,n,flag);
		*(ptr+temp)=node->key;
		temp--;
		Decrease_sort(node->rchild,n,flag);
	}
}
void Search_element(avlnode*node,Elementtype e)//查找元素e
{
	if(node==NULL)
	{
		printf("\n查找失败！二叉树中不含有元素%d\n",e);
		return;
	}
	if(e<node->key)
	{
		printf("%d ",node->key);
		Search_element(node->lchild,e);

	}
	else if(e>node->key)
	{
		printf("%d ",node->key);
		Search_element(node->rchild,e);
	}
	else
	{
		printf("%d \n",node->key);
		printf("查找成功！二叉树中含有元素%d\n",e);
		return;
	}
}
void Insert_element(avlnode *&node,Elementtype e)//插入结点
{
	avlnode* b=NULL;
	b=Insertnode(node,e);//插入结点,返回该结点
	Parent_adjust(node);//建立父结点指向
	Operation_AVL(node,b);
}
void Delete_element(avlnode*&snode,avlnode*node,Elementtype e,int n)//删除某个结点
{
	if(node==NULL)
	{
		//没找到该元素直接返回，查找失败
		printf("二叉树中不含有需要删除的元素%d\n",e);
		return;
	}
	if(e<node->key)
		Delete_element(snode,node->lchild,e,n);
	else if(e>node->key)
		Delete_element(snode,node->rchild,e,n);
	//找到元素值为e的结点node
	else
	{
		avlnode* b=NULL;
		//结点是叶子结点
		if(node->lchild==NULL && node->rchild==NULL)
 		{
 			b=node->parent;
 			if(b==NULL)//删除的是根结点
 			    snode=NULL;
			else//删除的不是根结点
			{
		 		//清除孩子结点和父结点指向
				if(node->parent->lchild==node)
					node->parent->lchild=NULL;
				else if(node->parent->rchild==node)
					node->parent->rchild=NULL;
				node->parent=NULL;
				Operation_AVL(snode,b);//进行调整
			}
		}
		//结点是单分支结点
		else if(node->lchild==NULL&&node->rchild!=NULL || node->lchild!=NULL&&node->rchild==NULL)//结点是单分支结点
		{
			if(node->parent==NULL)//删除的是根结点
			{
				if(node->lchild!=NULL)//根结点的左孩子不空
				{
					snode=node->lchild;
					node->lchild->parent=node->parent;
					free(node);
				}
				else//根结点的右孩子不空
				{
					snode=node->rchild;
					node->rchild->parent=node->parent;
					free(node);
				}
			}
			else//删除的不是根结点
			{
				//用单分支结点的左孩子结点或者是右孩子结点取缔要被删除的结点
				if(node->lchild!=NULL)//左孩子不空
				{
					node->lchild->parent=node->parent;

					if(node->parent->lchild==node)//左孩子是要删除的
							node->parent->lchild=node->lchild;
					else//右孩子是要删除的
							node->parent->rchild=node->lchild;

	 				b=node->lchild;//从替换的结点开始向根结点方向寻找不平衡的点
					node->lchild=NULL;
					node->parent=NULL;
					free(node);
				}
				//用单分支结点的左孩子结点或者是右孩子结点取缔要被删除的结点
				else if(node ->rchild!=NULL)//右孩子不空
				{
					node->rchild->parent=node->parent;
					if(node->parent->lchild==node)//左孩子是要删除的
							node->parent->lchild=node->rchild;
					else//右孩子是要删除的
							node->parent->rchild=node->rchild;
					b=node->rchild;//从替换的结点开始向根结点方向寻找不平衡的点
					node->rchild==NULL;
					node->parent==NULL;
					free(node);
				}
				//看是否平衡,不平衡就操作
				Operation_AVL(snode,b);//进行调整
			}
		}
		//结点是双分支结点
		else
		{
			avlnode* tnode=NULL;//储存前驱结点
			//找出中序遍历的前驱结点替换该结点
			tnode=Inorder(snode,e,n);		//中序遍历前驱结点,可能是叶子结点或者是单分支结点
			if(node->parent==NULL)//删除的是根结点
			{
				snode=tnode;	//根结点变化
				tnode->rchild=node->rchild;//连接右边
				if(node->rchild!=NULL)
					node->rchild->parent=tnode;
				b=snode;
				if(node->lchild!=tnode)	//前驱结点不是根结点的左孩子,左边连接需要进一步操作
				{
					//tnode可能存在左孩子
					tnode->parent->rchild=tnode->lchild;
					if(tnode->lchild!=NULL)
						tnode->lchild->parent=tnode->parent;
					
					tnode->lchild=node->lchild;//连接左边
					node->lchild->parent=tnode;
				}
				tnode->parent=node->parent;
				free(node);
				Operation_AVL(snode,b);
			}
			else//删除的不是根结点
			{
				tnode->rchild=node->rchild;//连接右边
				if(node->rchild!=NULL)
					node->rchild->parent=tnode;
				b=node;
				if(node->lchild!=tnode)//前驱结点不是根结点的左孩子,左边连接需要进一步操作
				{
					tnode->parent->rchild=tnode->lchild;
					if(tnode->lchild!=NULL)
						tnode->lchild->parent=tnode->parent;

					tnode->lchild=node->lchild;//连接左边
					node->lchild->parent=tnode;
				}
				tnode->parent=node->parent;
				if(node->parent->rchild==node)
					tnode->parent->rchild=tnode;
				else
					tnode->parent->lchild=tnode;
				Operation_AVL(snode,b);
			}
		}
	}
}
avlnode *Search(avlnode*node,Elementtype e)
{
	if(e<node->key)
	{
		Search(node->lchild,e);
	}
	else if(e>node->key)
	{
		Search(node->rchild,e);
	}
	//找到中序遍历的前驱结点
	else
	{
		printf("%d",node->key);
		return node;
	}
}
avlnode *Inorder(avlnode *node,Elementtype e,int n)
{
	int t=0;
	//找到中序遍历前驱结点的key
	for(int i=0;i<n;i++)
	{
		if(*(ptr1+i)==e)
		{
			t=*(ptr1+i+1);
			break;
		}
	}
	return Search(node,t);
}

void Operation_AVL(avlnode*& node,avlnode*b)
{
	avlnode *s=NULL;
	while (b != NULL && abs( Get_height(b->lchild) - Get_height(b->rchild) ) != 2)
			b = b->parent;
		if (b != NULL)//说明出现了不平衡，且b结点是离插入结点最近不平衡结点
		{
			if (b->parent==NULL)//根结点不平衡
			{
			if ((Get_height(b->lchild) - Get_height(b->rchild)) == 2)
				{
					if (( Get_height(b->lchild->lchild)-Get_height(b->lchild->rchild) )==1)//LL root
					{
						s = b->lchild;          	//s是失衡结点的左孩子
						node=s;		   				//根结点变为s,关键的一步！！！
						s->parent = b->parent; 		//s的父结点等于失衡结点的父结点
						b->lchild = s->rchild; 		//失衡结点的左孩子等于s的右孩子
						if(s->rchild!=NULL)
							s->rchild->parent=b;   //s的右孩子结点的父结点等于失衡结点
						s->rchild = b;		   	   //s的右结点等于失衡结点
						b->parent = s;		   	   //失衡结点的父结点等于s
					}
					else if (( Get_height(b->lchild->lchild)-Get_height(b->lchild->rchild) )==-1)//LR   root
					{
						s=b->lchild->rchild;        //s等于刚插入的结点
						node=s;                     //s作为根结点
						s->parent->rchild=s->lchild;//s的父结点的右孩子等于s的左孩子
						if(s->lchild!=NULL)         //如果s的左孩子不空，s的左孩子的父结点等于s的父结点
							s->lchild->parent=s->parent;
						b->lchild=s->rchild;        //b的左孩子等于s的右孩子
						if(s->rchild!=NULL)         //如果s的右孩子结点不空，那么s的右孩子的父结点等于b
							s->rchild->parent=b;
						s->lchild=s->parent;        //s的左孩子等于s的父结点
						s->parent->parent=s;        //s的父结点的父结点等于s
						s->parent=b->parent;        //s->父结点等于b的父结点，该步骤往后面放，防止父结点提前为空
						s->rchild=b;                //s的右孩子结点等于b
						b->parent=s;                //b的父结点等于s
					}
					else//删除操作会出现的一种特殊情况，两种调整都行
					{
						s=b->lchild;
						node=s;
						s->parent=b->parent;
						b->lchild=s->rchild;
						if(s->rchild!=NULL)
							s->rchild->parent=b;
						s->rchild=b;
						b->parent=s;
					}
				}
				else if ((Get_height(b->lchild) - Get_height(b->rchild)) == -2)
				{
					if ( ( Get_height(b->rchild->lchild)-Get_height(b->rchild->rchild) )==1)//RL root
					{
						s = b->rchild->lchild;
						node=s;
						s->parent->lchild=s->rchild;
						if(s->rchild!=NULL)
							s->rchild->parent=s->parent;
						b->rchild=s->lchild;
						if(s->lchild!=NULL)
							s->lchild->parent=b;
						s->rchild=s->parent;
						s->parent->parent=s;
						s->parent=b->parent;
						s->lchild=b;
						b->parent=s;
					}
					else if ( ( Get_height(b->rchild->lchild)-Get_height(b->rchild->rchild) )==-1)//RR root
					{
						s=b->rchild;            //s是失衡结点的右孩子
						node=s;                   //根结点变为s
						s->parent=b->parent;    //s的父结点等于失衡结点的父结点
						b->rchild=s->lchild;    //失衡结点的右孩子等于s的左孩子
						if(s->lchild!=NULL)     //如果s的左孩子不空，s的左孩子的父结点等于失衡结点
							s->lchild->parent=b;
						s->lchild=b;            //s的左孩子等于失衡结点
						b->parent=s;            //失衡结点的父结点等于s
					}
					else
					{
						s=b->rchild;
						node=s;
						s->parent=b->parent;
						b->rchild=s->lchild;
						if(s->lchild!=NULL)
							s->lchild->parent=b;
						s->lchild=b;
						b->parent=s;
					}
				}
			}
			else//其它结点不平衡
			{
				if ((Get_height(b->lchild) - Get_height(b->rchild)) == 2)
				{
					if (( Get_height(b->lchild->lchild)-Get_height(b->lchild->rchild) )==1)//LL not root
					{
						s=b->lchild;    		//s等于失衡结点的左孩子
						s->parent=b->parent;	//s的父结点等于失衡结点的父结点
						if(b->parent->lchild==b)
							b->parent->lchild=s;	//失衡结点的父结点的左孩子等于s
						else
							b->parent->rchild=s;
						b->lchild=s->rchild;	//失衡结点的左孩子等于s的右孩子
						if(s->rchild!=NULL)		//如果s的右孩子不空，那么s的右孩子的父结点等于失衡结点
							s->rchild->parent=b;
						s->rchild=b;			//s的右孩子等于失衡结点
						b->parent=s;			//失衡结点的父结点等于s
					}
					else if (( Get_height(b->lchild->lchild)-Get_height(b->lchild->rchild) )==-1)//LR  not root
					{
						s=b->lchild->rchild;            //s等于刚插入的结点
						s->parent->rchild=s->lchild;
						if(s->lchild!=NULL)
							s->lchild->parent=s->parent;
						b->lchild=s->rchild;
						if(s->rchild!=NULL)
							s->rchild->parent=b;
						s->lchild=s->parent;        //s的左孩子等于s的父结点
						s->parent->parent=s;        //s的父结点的父结点等于s
						s->parent=b->parent;        //s->父结点等于b的父结点，该步骤往后面放，防止父结点提前为空
						if(b->parent->rchild==b)
							b->parent->rchild=s;    //b结点的父节点的左孩子等于s
						else
							b->parent->lchild=s;
						s->rchild=b;                //s的右孩子结点等于b
						b->parent=s;                //b的父结点等于s
					}
					else
					{
						s=b->lchild;    		//s等于失衡结点的左孩子
						s->parent=b->parent;	//s的父结点等于失衡结点的父结点
						if(b->parent->lchild==b)
							b->parent->lchild=s;	//失衡结点的父结点的左孩子等于s
						else
							b->parent->rchild=s;
						b->lchild=s->rchild;	//失衡结点的左孩子等于s的右孩子
						if(s->rchild!=NULL)		//如果s的右孩子不空，那么s的右孩子的父结点等于失衡结点
							s->rchild->parent=b;
						s->rchild=b;			//s的右孩子等于失衡结点
						b->parent=s;			//失衡结点的父结点等于s
					}
				}
				else if ((Get_height(b->lchild) - Get_height(b->rchild)) == -2)
				{
					if (( Get_height(b->rchild->lchild)-Get_height(b->rchild->rchild) )==1)//RL not root
					{
						s=b->rchild->lchild;
						s->parent->lchild=s->rchild;
						if(s->rchild!=NULL)
							s->rchild->parent=s->parent;
						b->rchild=s->lchild;
						if(s->lchild!=NULL)
							s->lchild->parent=b;
						s->rchild=s->parent;
						s->parent->parent=s;
						s->parent=b->parent;
						if(b->parent->rchild==b)
							b->parent->rchild=s;
						else
							b->parent->lchild=s;
						s->lchild=b;
						b->parent=s;
					}
					else if (( Get_height(b->rchild->lchild)-Get_height(b->rchild->rchild) )==-1)//RR  not root
					{
						s=b->rchild;
						s->parent=b->parent;
						if(b->parent->rchild==b)
							b->parent->rchild=s;
						else
							b->parent->lchild=s;
						b->rchild=s->lchild;
						if(s->lchild!=NULL)
							s->lchild->parent=b;
						s->lchild=b;
						b->parent=s;
					}
					else
					{
						s=b->rchild;
						s->parent=b->parent;
						if(b->parent->rchild==b)
							b->parent->rchild=s;
						else
							b->parent->lchild=s;
						b->rchild=s->lchild;
						if(s->lchild!=NULL)
							s->lchild->parent=b;
						s->lchild=b;
						b->parent=s;
					}
				}
			}
		}
}
void Print_AVL(avlnode* bt)//打印AVL树
{
	if (bt != NULL)
	{
		printf("%d", bt->key);
		if (bt->lchild != NULL || bt->rchild != NULL)
		{
			printf("(");
			Print_AVL(bt->lchild);
			if (bt->rchild != NULL)printf(",");
			Print_AVL(bt->rchild);
			printf(")");
		}
	}

}在这里插入代码片
DongLUOWAN
关注
  • 9
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
二叉树相关算法实现
xxxxx
09-21 1348
二叉树打印所有节点 前序，中序，后序 public class Node { public int value; public Node left; public Node right; public Node(int value) { this.value = value; } } //前序递归 public void preOrder(Node head) { if(head ...
数据结构课设 - 平衡二叉树的演示
戮漠
02-03 1570
平衡二叉树的演示课设报告下载： 一、需求分析： （1） 构建一个平衡二叉树并实现创建、插入、查找、删除、销毁等操作。每种操作均提示输入关键字。每次插入或删除一个结点后，更新平衡二叉树的显示。 （2） 平衡二叉树的显示采用凹入表现形式。 （3）输入的形式时数字，无论对功能的选择还是对数据的录入，都是以数字的形式进行输入，无需使用文件保存数据。  （4） 输出的形式时在dos界面进行输出，一旦检测到错...
数据结构平衡二叉树课程设计
02-22
C语言编写的 数据结构 平衡二叉树 演示、含课程设计报告 多种输出平衡二叉树格式
【数据结构】平衡二叉树（AVL) C语言实现
crr411422的博客
04-05 1779
平衡二叉树，也称为 AVL 树，是一种二叉排序树，用于解决二叉排序树高度不确定的情况。可以是空树；左子树和右子树的高度之差的绝对值小于等于1；左子树和右子树也是平衡二叉树。插入结点后，最小不平衡子树的BF与它的子树的BF符号相反时，就需要对结点先进行一次旋转以使得符号相同后，再反向旋转一次才能够完成平衡操作。
平衡二叉树算法实现课设（附：源码与文档）
qq_52683382的博客
07-11 594
平衡二叉树算法实现课设
数据结构课程设计（六）---平衡二叉排序树操作的演示
zhulinhao的博客
06-22 2790
1、任务简述： 利用平衡二叉排序树实现一个动态查找表。 要求： （1）随机生成数据，根据随机数据创建平衡的BST （2）以图形方式显示该平衡的BST（注意是图形，不是图像，利用画图函数） （3）实现平衡二叉树的插入、删除、查找功能。 （4）操作方便。 2、算法描述： 1.创建BST：对于每一个随机生成的数据，我们用插入来生成BST，即每一次插入后，我们检查相应的平衡因子（左子树高度减去右子树高度），一直检查到0为止，如果出现abs(平衡高度)>=2，那么就进行一次adjust，有四种情况：RR,LL,
数据结构 平衡二叉树
Aming_sth的博客
03-27 631
平衡二叉树1. 平衡二叉树的基本概念1.1二叉查找树的问题1.2平衡二叉树的概念1.3平衡二叉树的作用2. 平衡二叉树的左旋右旋2.1 左旋或者右旋的触发时机2.2 左旋的过程2.3右旋的过程2.4平衡二叉树旋转的四种情况2.4.1左左2.4.2 左右2.4.3 右右2.4.4右左 1. 平衡二叉树的基本概念 1.1二叉查找树的问题 在极端的情况下,二叉树就会转换成链表,高度太高,效率变低 1.2平衡二叉树的概念 任意结点的左子树或右子树的度相差 不超过1 1.3平衡二叉树的作用 通过降低树的高度,从而提高
数据结构课程设计——平衡二叉树的实现
04-30
在数据结构课程设计中，平衡二叉树的实现是一个重要的实践环节，旨在加深对数据结构和算法的理解。平衡二叉树是一种特殊的二叉树，它确保了任何节点的两个子树的高度差不超过1，从而保证了操作如查找、插入和删除的...
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
数据结构课程设计编程实例——基于Win32 API编程学习视频__下
12-04
数据结构是计算机科学中的核心课程，它探讨了如何有效地存储和组织数据，以便于高效地进行访问和操作。本课程设计编程实例聚焦于利用Win32 API进行实践，这是一个底层的Windows操作系统接口，允许程序员直接与操作...
数据结构课程设计\二叉平衡排序树
05-29
数据结构课程设计\二叉平衡排序树 c语言实现 超完整（包括任务书，说明书，源代码等）
数据结构-二叉树（Java实现）
11-27
编程实现如下功能： 1、假设二叉树的结点值是字符...2、对二叉树进行先根、中根和后根遍历操作，并输出遍历序列，同时观察输出序列是否与逻辑上的序列一致。 3、统计二叉树的结点个数和叶子结点个数，并分别输出其值。
数据结构实验——树和二叉树子系统
07-31
在本实验“数据结构实验——树和二叉树子系统”中，我们将深入理解二叉树的特性和操作。 首先，实验目的主要涵盖以下几个方面： 1. **理解二叉树特点**：二叉树的每个节点至多有两个子节点，它允许快速查找、插入...
小程序二叉树级菜单选择组件
Mo_jon的博客
04-13 759
小程序二叉树级菜单组件
平衡二叉树（AVL树）创建、查找、插入操作 《大话数据结构》 c++实现代码
m0_38047231的博客
10-31 1214
//平衡二叉树，或者称为AVL树 #include&lt;iostream&gt; using namespace std; typedef int status; #define true 1 #define false 0 #define LH +1 //左高 #define EH 0 //等高 #define RH -1 //右高 //二叉链表结点结构定义 ...
c语言二叉树的遍历菜单系统,二叉树遍历C语言的实现
weixin_39667797的博客
05-18 619
广告提供50多种云计算产品，包括云服务器和云. 创建一站式云产品试用服务，以帮助开发人员和企业以零门槛进入云环境.上面的代码很简单，上面的图片很容易理解. 下一点是焦点: 二叉树的遍历分为前遍，中遍，后遍，序列遍历. 要理解以下内容，建议再次观看此视频http: pan.baidu.coms1i3yyd2t首先讨论最简单的序列遍历，顾名思义，从上到下遍历遍历，因此遍历顺序为abcdefg ...全...
c语言二叉树的遍历菜单系统,C语言二叉树的三种遍历方式的实现及原理
weixin_42614269的博客
05-18 351
C语言二叉树的三种遍历方式的实现及原理发布时间：2020-10-03 19:43:57来源：脚本之家阅读：63作者：看雪。二叉树遍历分为三种：前序、中序、后序，其中序遍历最为重要。为啥叫这个名字？是根据根节点的顺序命名的。比如上图正常的一个满节点，A：根节点、B：左节点、C：右节点，前序顺序是ABC(根节点排最先，然后同级先左后右)；中序顺序是BAC(先左后根最后右)；后序顺序是BCA(先左后右最...
平衡二叉树的定义及基本操作（查找、插入、删除）及代码实现
薛定谔的猫的博客
08-12 4447
文章目录平衡二叉树的定义平衡二叉树的插入 平衡二叉树的定义  为了避免树的高度增长过快，降低二叉排序树的性能，我们规定在插入和删除二叉树结点时，要保证在任意结点的左、右子树高度差的绝对值不超过1，将这样的树称为平衡二叉树（Balanced Binary Tree），简称平衡树（AVL）。  定义结点左子树与右子树的高度差为该结点的平衡因子，则平衡二叉树结点的平衡因子的值只可能是-1，0或1 。 平衡二叉树可定义为：  或者是一棵空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和
高阶数据结构——B树
最新发布
weixin_74310945的博客
08-08 684
B树：有序数组+平衡多叉树；B+树：有序数组链表+平衡多叉树；B*树：一棵更丰满的，空间利用率更高的B+树。单论树的高度，查找效率来看B树系列确实不错，但是也存在一些缺点。1.空间利用率低，占用的空间大。2.插入和删除数据时，需要进行分裂，涉及到数据的挪动，效率低。3.虽然比起红黑树等，高度更低，但是在内存中都是一个量级的，搜索效率并不比红黑树快多少（在内存中没什么优势）
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值