严蔚敏数据结构平衡二叉树

于 2022-05-09 19:59:53 发布
阅读量177 收藏 1
点赞数
文章标签： c语言 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuchishizi/article/details/124673823
版权 
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <math.h>
#define OK 1
#define ERROR 0
#define FALSE 0
#define TRUE 1
#define OVERFLOW -2
#define LH 1
#define RH -1
#define EH 0
#define GRADE 4
typedef int Status;
typedef int KeyType;
typedef struct
{
	KeyType key;
}ElemType;
typedef struct
{
	ElemType* elem;
	int length;
}SSTable;
typedef ElemType TElemType;
typedef struct BiTNode
{
	TElemType data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
typedef struct BSTNode
{
	TElemType data;
	int bf;
	struct BSTNode* lchild, * rchild;
}BSTNode, * BSTree;
typedef struct BTNode
{
	int keynum;
	struct BTNode* parent;
	KeyType key[GRADE + 1];
	struct BTNode* ptr[GRADE + 2];
	ElemType* recptr[GRADE + 1];
}BTNode, * BTree;
typedef struct
{
	BTNode* ptr;
	int i;
	int tag;
}Result;


//查找表元素输入,关键字赋值以及比较
void InputTableElem(ElemType* e)
{
	printf("请输入关键字信息\n");
	scanf("%d", &(e->key));
}
void KeyWordAssign(KeyType* destination, KeyType source)
{
	(*destination) = source;
}
void KeyWordPrint(KeyType key)
{
	printf("%d\n", key);
}
void TableElemAssign(ElemType* destination, ElemType source)
{
	(*destination).key = source.key;
}
void TableElemPrint(ElemType e)
{
	printf("%d\n", e.key);
}
Status EQ(KeyType key1, KeyType key2)
{
	if (key1 == key2)
		return TRUE;
	else
		return FALSE;
}
Status LT(KeyType key1, KeyType key2)
{
	if (key1 < key2)
		return TRUE;
	else
		return FALSE;
}
Status LE(KeyType key1, KeyType key2)
{
	if (key1 <= key2)
		return TRUE;
	else
		return FALSE;
}
Status MT(KeyType key1, KeyType key2)
{
	if (key1 > key2)
		return TRUE;
	else
		return FALSE;
}
Status ME(KeyType key1, KeyType key2)
{
	if (key1 >= key2)
		return TRUE;
	else
		return FALSE;
}


//静态查找表
Status CreatSSTable(SSTable* T, int n)
{
	T->length = n;
	T->elem = (ElemType*)malloc(sizeof(ElemType) * (n + 1));
	if (!T->elem) exit(OVERFLOW);
	for (int i = 1; i <= T->length; i++)
	{
		printf("请输入第%d个表项信息：\n", i);
		InputTableElem(&(T->elem[i]));
	}
	return OK;
}
int Search_Seq(SSTable ST, KeyType key)                   //Sequence Search
{
	KeyWordAssign(&(ST.elem[0].key), key);
	int i = ST.length;
	while (!EQ(ST.elem[i].key, key))
		i--;
	return i;
}
int Search_Bin(SSTable ST, KeyType key)                    //Binary Search
{
	int low = 1, high = ST.length;
	int mid = (low + high) / 2;
	while (low <= high)
	{
		if (EQ(ST.elem[mid].key, key))
			return mid;
		if (MT(ST.elem[mid].key, key))
			high = mid - 1;
		else
			low = mid + 1;
	}
	return 0;
}
void SecondOptimal(BiTree* T, SSTable S, int* sw, int low, int high)
{
	int i = low;
	int w = sw[high] + sw[low - 1];
	int min = abs(sw[high] - sw[low]);
	for (int j = low + 1; j <= high; j++)
	{
		if (abs(w - sw[j - 1] - sw[j]) < min)
		{
			i = j;
			min = abs(w - sw[i] - sw[i - 1]);
		}
	}
	(*T) = (BiTree)malloc(sizeof(BiTNode));
	if (!(*T)) exit(OVERFLOW);
	KeyWordAssign(&((*T)->data.key), S.elem[i].key);
	if (i == low)
		(*T)->lchild = NULL;
	else
		SecondOptimal(&((*T)->lchild), S, sw, low, i - 1);
	if (i == high)
		(*T)->rchild = NULL;
	else
		SecondOptimal(&((*T)->rchild), S, sw, i + 1, high);
}


//队列函数
typedef BSTNode* QElemType;
typedef struct QNode
{
	QElemType data;
	struct QNode* next;
}QNode, * QueuePtr;
typedef struct
{
	QueuePtr head, tail;
}LinkQueue;
Status InitQueue(LinkQueue* Q)
{
	Q->head = (QueuePtr)malloc(sizeof(QNode));
	if (!Q->head) exit(OVERFLOW);
	Q->tail = Q->head;
	Q->head->next = NULL;
	return OK;
}
Status EnQueue(LinkQueue* Q, QElemType e)
{
	QNode* p;
	p = (QNode*)malloc(sizeof(QNode));
	if (!p) exit(OVERFLOW);
	p->data = e;
	Q->tail->next = p;
	Q->tail = p;
	Q->tail->next = NULL;
	return OK;
}
Status DeQueue(LinkQueue* Q, QElemType* e)
{
	if (Q->head == Q->tail)
		return ERROR;
	QNode* p = Q->head->next;
	(*e) = p->data;
	Q->head->next = p->next;
	if (p == Q->tail)
		Q->tail = Q->head;
	free(p);
	return OK;
}
Status QueueEmpty(LinkQueue Q)
{
	if (Q.head == Q.tail)
		return TRUE;
	else
		return FALSE;
}


//平衡二叉树
void Rotate_L(BSTree* T)
{
	BSTNode* rc = (*T)->rchild;
	BSTNode* new = (BSTNode*)malloc(sizeof(BSTNode));
	if (!new) exit(OVERFLOW);
	TableElemAssign(&(new->data), (*T)->data);
	new->lchild = (*T)->lchild;
	(*T)->lchild = new;
	new->rchild = rc->lchild;
	(*T)->rchild = rc->rchild;
	TableElemAssign(&((*T)->data), rc->data);
	(*T)->bf = EH;
	new->bf = EH;
	free(rc);
}
void Rotate_RL(BSTree* T)
{
	BSTNode* rc = (*T)->rchild, * rc_lc = rc->lchild;
	BSTNode* new;
	//右旋代码
	new = (BSTNode*)malloc(sizeof(BSTNode));
	if (!new) exit(OVERFLOW);
	TableElemAssign(&(new->data), rc->data);
	new->rchild = rc->rchild;
	new->lchild = rc_lc->rchild;
	rc->rchild = new;
	TableElemAssign(&(rc->data), rc_lc->data);
	rc->lchild = rc_lc->lchild;
	int bf_rem = rc_lc->bf;
	free(rc_lc);
	//左旋代码
	new = (BSTree)malloc(sizeof(BSTNode));
	if (!new) exit(OVERFLOW);
	TableElemAssign(&(new->data), (*T)->data);
	new->lchild = (*T)->lchild;
	new->rchild = rc->lchild;
	(*T)->lchild = new;
	TableElemAssign(&((*T)->data), rc->data);
	(*T)->rchild = rc->rchild;
	free(rc);
	switch (bf_rem)
	{
	case LH:
		(*T)->lchild->bf = EH;
		(*T)->rchild->bf = RH;
		break;
	case EH:
		(*T)->lchild->bf = EH;
		(*T)->rchild->bf = EH;
		break;
	case RH:
		(*T)->lchild->bf = LH;
		(*T)->rchild->bf = EH;
		break;
	}
	(*T)->bf = EH;
}
void Rotate_R(BSTree* T)
{
	BSTNode* lc = (*T)->lchild;
	BSTNode* new = (BSTree)malloc(sizeof(BSTNode));
	if (!new) exit(OVERFLOW);
	TableElemAssign(&(new->data), (*T)->data);
	new->rchild = (*T)->rchild;
	new->lchild = lc->rchild;
	TableElemAssign(&((*T)->data), lc->data);
	(*T)->lchild = lc->lchild;
	free(lc);
	(*T)->bf = EH;
	new->bf = EH;
}
void Rotate_LR(BSTree* T)
{
	BSTNode* lc = (*T)->lchild, * lc_rc = (*T)->lchild->rchild;
	BSTNode* new = (BSTree)malloc(sizeof(BSTNode));
	if (!new) exit(OVERFLOW);
	TableElemAssign(&(new->data), lc->data);
	new->lchild = lc->lchild;
	new->rchild = lc_rc->lchild;
	lc->lchild = new;
	TableElemAssign(&(lc->data), lc_rc->data);
	lc->rchild = lc_rc->rchild;
	int bf_rem = lc_rc->bf;
	free(lc_rc);
	new = (BSTNode*)malloc(sizeof(BSTNode));
	if (!new) exit(OVERFLOW);
	TableElemAssign(&(new->data), (*T)->data);
	new->rchild = (*T)->rchild;
	new->lchild = lc->rchild;
	(*T)->rchild = new;
	TableElemAssign(&((*T)->data), lc->data);
	(*T)->lchild = lc->lchild;
	free(lc);
	switch (bf_rem)
	{
	case LH:
		(*T)->lchild->bf = EH;
		(*T)->rchild->bf = RH;
		break;
	case EH:
		(*T)->lchild->bf = EH;
		(*T)->rchild->bf = EH;
		break;
	case RH:
		(*T)->lchild->bf = LH;
		(*T)->rchild->bf = EH;
		break;
	}
	(*T)->bf = EH;
}
void RightBalance(BSTree* T)
{
	BSTNode* rc = (*T)->rchild;
	switch (rc->bf)
	{
	case RH:Rotate_L(T); break;
	case LH:Rotate_RL(T); break;
	}
}
void LeftBalance(BSTree(*T))
{
	BSTNode* lc = (*T)->lchild;
	switch (lc->bf)
	{
	case LH:Rotate_R(T); break;
	case RH:Rotate_LR(T); break;
	}
}
Status InsertAVL(BSTree* T, ElemType e, int* taller)
{
	if (!(*T))
	{
		*T = (BSTree)malloc(sizeof(BSTNode));
		if (!(*T)) exit(OVERFLOW);
		TableElemAssign(&((*T)->data), e);
		(*T)->lchild = NULL;
		(*T)->rchild = NULL;
		(*T)->bf = EH;
		*taller = TRUE;
	}
	else
	{
		if (EQ((*T)->data.key, e.key))
		{
			(*taller) = FALSE;
			return FALSE;
		}
		else
		{
			if (LT((*T)->data.key, e.key))
			{
				if (!InsertAVL(&((*T)->rchild), e, taller))
					return FALSE;
				if ((*taller) == TRUE)
				{
					switch ((*T)->bf)
					{
					case LH:
						(*T)->bf = EH;
						(*taller) = FALSE;
						break;
					case EH:
						(*T)->bf = RH;
						(*taller) = TRUE;
						break;
					case RH:
						RightBalance(T);
						(*taller) = FALSE;
						break;
					}
				}
			}
			else
			{
				if (!InsertAVL(&((*T)->lchild), e, taller))
					return FALSE;
				if ((*taller) == TRUE)
				{
					switch ((*T)->bf)
					{
					case RH:
						(*T)->bf = EH;
						(*taller) = FALSE;
						break;
					case EH:
						(*T)->bf = LH;
						(*taller) = TRUE;
						break;
					case LH:
						LeftBalance(T);
						(*taller) = FALSE;
						break;
					}
				}
			}
		}

	}
	return OK;
}
void PrintBSTree(BSTree T)
{
	LinkQueue Q;
	InitQueue(&Q);
	EnQueue(&Q, T);
	QElemType p;
	while (!QueueEmpty(Q))
	{
		DeQueue(&Q, &p);
		KeyWordPrint(p->data.key);
		if (p->lchild)
			EnQueue(&Q, p->lchild);
		if (p->rchild)
			EnQueue(&Q, p->rchild);
	}
}

主函数：

//平衡二叉树的插入
int main()
{
	BSTree T = NULL;
	int taller;
	ElemType e[5];
	for (int i = 0; i < 5; i++)
	{
		taller = FALSE;
		InputTableElem(&(e[i]));
		InsertAVL(&T, e[i], &taller);
	}
	PrintBSTree(T);
	return 0;
}

输入：（P234中的基本左右旋为例）

13
24
37
90
53

输出：

 

 

哆啦BCD梦
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉排序树（二叉查找树）及C语言实现
数据结构和算法教程（C语言版）
03-19 3851
前几节介绍的都是有关静态查找表的相关知识，从本节开始介绍另外一种查找表——动态查找表。 动态查找表中做查找操作时，若查找成功可以对其进行删除；如果查找失败，即表中无该关键字，可以将该关键字插入到表中。 动态查找表的表示方式有多种，本节介绍一种使用树结构表示动态查找表的实现方法——二叉排序树（又称为“二叉查找树”）。 什么是二叉排序树？ 二叉排序树要么是空二叉树，要么具有如下特点： 二叉排序树...
栈（Stack）和队列（Queue）的基本操作
qq_19926581的博客
08-14 723
栈和队列的基本操作
【数据结构】深入理解二叉排序树和平衡二叉树AVL树（c语言）
亦梦亦醒乐逍遥的博客
11-20 1262
本文案例提取于严蔚敏《数据结构c语言》 二叉排序树是基础，简单说一下，不难。 基本定义简言之就是根节点的值大于左孩子小于右孩子。 重要性质：一直往左就是最小，一直往右就是最大。 插入： 就是递归，小就往左插，大就往右插，等于就不插。 删除： 两种操作，分别理解一下，书里说的太学术化。 第一种。直接把p摘掉，把p的leftchild作为f的leftchild，那么问题来了，p的rightchild呢？分析一下，p的rightchild比p大，所以一定比p左边的左右东西都大，而没了p后，p左边的
数据结构C语言版清华大学严蔚敏（学习笔记总结6）——查找全代码：二分查找、折半查找、分块查找、哈希查找、哈希表、平衡二叉树【另附学习笔记】
weixin_51538341的博客
01-02 1242
一. 二分查找（折半查找） 核心思想：将nn个元素分成个数大致相同的两半，取a[n/2]a[n/2]与欲查找的xx作比较，如果x=a[n/2]x=a[n/2]则找到xx，算法终止。如果x<a[n/2]x<a[n/2]，则我们只要在数组aa的左半部继续搜索xx（这里假设数组元素呈升序排列）。如果x>a[n/2]x>a[n/2]，则我们只要在数组a的右 半部继续搜索x.其算法时间复杂度O(lgn) //c/c++ int binary_find(int *num,int le..
链表中p->next=head->next;语句解析
热门推荐
浅然的专栏
09-30 3万+
在看到一些书上或者网上写的不管是单链表还是双向循环链表等，都会有p->next=q->next;或者p-next=head->next; 这里q是尾指针，head是头指针，p是指向新建结点的指针 该语句作用 这条语句的作用其实就是给新建结点找到它该有的位置 该语句在单链表下的头插法是必须存在的，而在双向循环下可有可无1.单链表的头插法下p-next=head->next;LinkLis
严蔚敏版数据结构所有算法代码
07-02
严蔚敏版数据结构所有算法代码，严蔚敏版数据结构所有算法代码
数据结构 严蔚敏 代码
03-14
范例1-97 平衡二叉树的基本操作 285 ∷相关函数：SearchBST函数 1.6.5 B树的基本操作 290 范例1-98 B树的基本操作 290 ∷相关函数：SearchBTree函数 1.6.6 按关键字符串的遍历双链键树 295 范例1-99 按关键字符串...
平衡二叉树实现算法 数据结构
08-22
平衡二叉树实现算法 c++ 数据结构 严蔚敏 完全正确
严蔚敏 数据结构(C语言版) 代码 23490 书中算法
04-21
7.3.2　平衡二叉树　176 7.3.3　B-树　182 7.3.4　B+树　190 7.4　散列表的查找　192 7.4.1　散列表的基本概念　192 7.4.2　散列函数的构造方法　193 7.4.3　处理冲突的方法　195 7.4.4　散列表的查找　198 7.5　小...
数据结构(C语言版)[严蔚敏]
04-27
9.2.1 二叉排序树和平衡二叉树 9.2.2 B树和B+树 9.2.3 键树 9.3 哈希表 9.3.1 什么是哈希表 9.3.2 哈希函数的构造方法 9.3.3 处理冲突的方法 9.3.4 哈希表的查找及其分析 第10章 内部排序 10.1 概述 10.2 插入排序 ...
数据结构之平衡二叉树的递归实现
12-05
平衡二叉树各种操作的递归实现
数据结构知识整理 - 平衡二叉树
春雪阁
12-27 268
平衡二叉树（Balanced Binary Tree） 平衡二叉树是由一般的二叉排序树经过平衡调整得到的，每个结点的左右子树深度差小于等于1的特殊的二叉排序树。 已经提到，二叉排序树的平均查找长度与它的形态有关，其中平衡二叉树就是一种最好的形态。 特征： 1）左右子树深度差的绝对值小于等于1； 2）左右子树也是平衡二叉树。（递归）   为了表示左右子树的深度差，我们给每个结点增加一个...
数据结构-平衡二叉树(AVL树)
理科男同学
11-15 2514
目录 1，平衡二叉树的介绍 1.1，二叉排序树存在的问题 1.2，平衡二叉树 1.3，平衡二叉树的创建 1.4，平衡二叉树的查找 2，代码实现 2.1，平衡二叉树的节点类型 2.2，LL旋转（单右旋转） 2.3，RR旋转（单左旋转） 2.4，向avl树中添加一个节点 2.5，求左右子树的高度 2.6，求平衡二叉树的高度 2.7，中序遍历二叉树 2.8，创建一颗平衡二叉树 3，测试代码 1，平衡二叉树的介绍 1.1，二叉排序树存在的问题 在介绍平衡二叉树之前，我们先来看看.
严蔚敏版数据结构——树和二叉树的常见知识点（持续更新……
Suryxin's blogs
05-05 1107
基本术语： 节点的度：节点具有的子树的个数 树的度：树的节点的度的最大值 非终端节点：除叶子结点以外的所有点，又叫分支节点 内部节点：出叶子结点和根结点外的所有的点 树的深度：树中结点的最大层次 森林： 由若干棵互不相交的树的集合。 二叉树 定义： 每个节点最多只有两个分支的树，可以为空树 特点： 每个节点至多俩子树，即没有节点的度大于2 有左右子树之分，不可颠倒 满二叉树： 深度为 k 且含有2k−12^k - 12k−1个节点的二叉树 其每一层上的节点树都是最大节点数，第 i 层有 2i−12^
数据结构——平衡二叉树的的旋转问题
suliangkuanjiayou的博客
12-29 1万+
对于画出一个平衡二叉树过程中的旋转需要交换孩子的问题！
平衡二叉树
gzj_1101的专栏
10-16 564
#include #include #define LH 1//左高 #define EH 0//等高 #define RH -1//右高 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 typedef int ElemType; typedef int Status; typedef int Boolean; typ
【数据结构】平衡二叉树之AVL树
weixin_30474613的博客
11-16 151
平衡二叉排序树 平衡二叉排序树(Balanced Binary Sort Tree)，上一篇博客【数据结构】二叉排序树BST讲了BST，并且在最后我们说BST上的操作不会超过O(h)，既然树高这么重要，那么BBST的研究就是为了使得树的深度在可接受的范围内渐近意义下达到O(lgn) n个节点组成的二叉树，其高度为lgn取下限时，这棵树是理想平衡的，满足这样条件的树只有完全二叉树和满二叉...
严蔚敏数据结构电子版
最新发布
05-16
严蔚敏的数据结构教材是目前国内最著名的数据结构教材之一，已经出版多个版本。其中电子版是指该教材的电子书版本，可以在电脑或其他电子设备上进行阅读。 这本教材详细讲解了数据结构的基本概念、常见的数据结构...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值