堆和平衡二叉树

于 2023-04-16 19:10:38 发布
阅读量374 收藏 1
点赞数 1
文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56569448/article/details/130186438
版权

堆：

是完全二叉树，不适合链式存储的树

大顶堆(大根堆)：

根节点比左右子树大

小顶堆(小根堆)：

根节点比左右子树小

数据项：

存储数据的内存首地址

容量

数量

运算：

创建、销毁、添加、删除、空堆、满堆、堆顶

83 86 77 15 93 35 86 92 49 21

堆结构的删除：

1、堆顶与末尾元素交换，删除末尾

2、对新堆顶从上往下重新调整成堆结构

堆的应用：

1、堆排序

不停地重复执行删除堆顶的操作，直到删除全部元素，最终整个存储元素的内存就有序了

2、优先队列

在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出的行为特征

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

#define SWAP(a,b) {typeof(a) t=(a);(a)=(b);(b)=t;}

//	大顶堆

typedef struct Heap
{
	TYPE* arr;
	size_t cal;
	size_t cnt;
}Heap;

//	创建
Heap* create_heap(int cal)
{
	Heap* heap = malloc(sizeof(Heap));
	heap->arr = malloc(sizeof(TYPE)*cal);
	heap->cal = cal;
	heap->cnt = 0;
	return heap;
}

//	空堆
bool empty_heap(Heap* heap)
{
	return 0 == heap->cnt;	
}

//	满堆
bool full_heap(Heap* heap)
{
	return heap->cnt >= heap->cal;	
}

//	添加 
bool add_heap(Heap* heap,TYPE data)
{
	if(full_heap(heap)) return false;
	heap->arr[heap->cnt++] = data;
	
	//	新加入的位置进行调整成大顶堆
	int index = heap->cnt;	//	编号
	while(index > 1)
	{
		if(heap->arr[index/2-1] < heap->arr[index-1])	
		{
			SWAP(heap->arr[index/2-1],heap->arr[index-1]);	
			index /= 2;
			continue;
		}
		return true;
	}
	return true;
}

void show_heap(Heap* heap)
{
	for(int i=0; i<heap->cnt; i++)
	{
		printf("%d ",heap->arr[i]);	
	}
	printf("\n");
}

//	删除堆顶
bool del_top_heap(Heap* heap)
{
	if(empty_heap(heap)) return false;

	//	堆顶与末尾交换
	SWAP(heap->arr[0],heap->arr[heap->cnt-1]);
	//	删除末尾
	heap->cnt--;

	//	从上到下重新调整成堆结构
	int index = 1;
	while(index <= heap->cnt)
	{
		//	有右子树，比较左右，谁大再与根比较，根小则交换
		if(index*2 < heap->cnt)
		{
			//	右比左大
			if(heap->arr[index*2] > heap->arr[index*2-1])
			{
				//	根小 交换右和根
				if(heap->arr[index*2] > heap->arr[index-1])
				{
					SWAP(heap->arr[index*2],heap->arr[index-1]);
					index = index*2+1;
				}
				else
					return true;
			}
			else	//左 大于等于 右
			{
				if(heap->arr[index*2-1] > heap->arr[index-1])
				{
					SWAP(heap->arr[index*2-1],heap->arr[index-1]);
					index = index*2;
				}
				else 
					return true;
			}
		}
		else if(index*2-1 < heap->cnt)//	只有左子树
		{
			if(heap->arr[index*2-1] > heap->arr[index-1])
			{
				SWAP(heap->arr[index*2-1],heap->arr[index-1]);
				index = index*2;
			}
			else
				return true;	
		}
		else
			return true;
	}
}

//	堆排序
void sort_heap(int* arr,int len)
{
	//	把数组调整成大顶堆结构
	for(int i=1; i<len; i++)
	{
		int index = i+1;	//编号
		while(index > 1)	
		{
			if(arr[index-1] > arr[index/2-1])
			{
				SWAP(arr[index-1],arr[index/2-1]);
				index = index/2;
			}
			else
				break;
		}
	}

	//	交换堆顶与末尾，有效个数-1，重新调整堆结构，直到有效个数为0
	while(len > 1)
	{
		SWAP(arr[0],arr[len-1]);
		len--;

		//从上往下调整
		int index = 1;	//编号
		while(index-1 < len)
		{
			if(index*2 < len)	//有右
			{
				//	右最大 交换根和右
				if(arr[index*2] > arr[index*2-1])
				{
					if(arr[index*2] > arr[index-1])
					{
						SWAP(arr[index*2],arr[index-1]);
						index = index*2+1;
					}
					else
						break;
				}
				else	//	左大于等于右
				{
					if(arr[index*2-1] > arr[index-1])	
					{
						SWAP(arr[index*2-1],arr[index-1]);
						index = index*2;
					}
					else
						break;
				}
			}
			else if(index*2-1 < len)	//只有左
			{
				if(arr[index*2-1] > arr[index-1])
				{
					SWAP(arr[index*2-1],arr[index-1]);
					index = index*2;
				}
				else
					break;
			}
			else
				break;
		}
	}
}

// 从top下标 到end下标 向下调整成堆结构
void _sort_heap(int* arr,int top,int end)
{
	if(top >= end) return;

	int max = top+1;	//编号
	int l = max*2;		//左子树编号
	int r = max*2+1;	//右子树编号

	if(l-1 <= end && arr[l-1] > arr[max-1])	//有左
	{
		max = l;	
	}
	if(r-1 <= end && arr[r-1] > arr[max-1])	//有右
	{
		max = r;	
	}
	if(max != top+1)
	{
		//	值最大的不是根，则交换
		SWAP(arr[max-1],arr[top]);
		_sort_heap(arr,max-1,end);
	}
}

//	堆排序递归实现
void sort_heap_recursion(int* arr,int len)
{
	//	把数组调整成大顶堆结构
	for(int i=1; i<len; i++)
	{
		int index = i+1;	//编号
		while(index > 1)	
		{
			if(arr[index-1] > arr[index/2-1])
			{
				SWAP(arr[index-1],arr[index/2-1]);
				index = index/2;
			}
			else
				break;
		}
	}

	for(int i=len-1; i>0; i--)
	{
		SWAP(arr[0],arr[i]);
		_sort_heap(arr,0,i-1);
	}
		
}


int main(int argc,const char* argv[])
{
	int arr[10] = {};
	for(int i=0; i<10; i++)
	{
		arr[i] = rand()%100;	
	}
	sort_heap_recursion(arr,10);
	for(int i=0; i<10; i++)
	{
		printf("%d ",arr[i]);	
	}
/*
	Heap* heap = create_heap(10);
	for(int i=0; i<10; i++)
	{
		add_heap(heap,rand()%100);	
	}
	show_heap(heap);

	del_top_heap(heap);
	show_heap(heap);
	*/
}

平衡二叉树：

前提是一棵有序二叉树，它的左右子树高度差不超过1，同时它的所有子树也要满足该条件

二叉树不平衡的四种基础原因：

  x                           y
           / \                        /   \
          y  t1                      z     x
         / \                        / \   / \
        z  t2   以y为轴右旋转       t3 t4 t2 t1
       / \
      t3 t4 

        x                               y
       / \                            /   \
      t1  y                          x     z
         / \    以y为轴左旋转        / \   / \
        t2  z                      t1 t2 t3 t4
           / \
          t3 t4
    
        x               x                   z
       / \             / \                /   \
      y   t1          z   t1             y     x
     / \             / \                / \   / \
    t2  z           y   t4             t2 t3 t4 t1
       / \         / \ 
      t3  t4      t2 t3
    以z为轴左旋转 以z为轴右旋转

        x               x                   z
       / \             / \                /   \
      t1  y           t1  z              x     y
         / \             / \            / \   / \
        z  t2           t3  y          t1 t3 t4 t2
       / \                 / \ 
      t3 t4               t4 t2 
    以z为轴右旋转    以z为轴左旋转
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct TreeNode
{
	int data;
	struct TreeNode* left;
	struct TreeNode* right;
}TreeNode;

//	创建节点
TreeNode* create_node(int data)
{
	TreeNode* node = malloc(sizeof(TreeNode));
	node->data = data;
	node->left = NULL;
	node->right = NULL;
	return node;
}

//	求高度
int high_tree(TreeNode* root)
{
	if(NULL == root) return 0;
	int lh = high_tree(root->left);
	int rh = high_tree(root->right);
	return lh>rh ? lh+1 : rh+1;
}

//	左右子树高度差
int diff_high(TreeNode* root)
{
	return high_tree(root->left) - high_tree(root->right);	
}

//	左旋转
TreeNode* left_rotate(TreeNode* x)
{
	TreeNode* y = x->right;
	TreeNode* t2 = y->left;

	y->left = x;
	x->right = t2;

	return y;
}

//	右旋转
TreeNode* right_rotate(TreeNode* x)
{
	TreeNode* y = x->left;
	TreeNode* t2 = y->right;

	y->right = x;
	x->left = t2;

	return y;
}

//	自动调整平衡
TreeNode* auto_balance(TreeNode* x)
{
	if(NULL == x) return NULL;
	int lh = high_tree(x->left);
	int rh = high_tree(x->right);

	if(lh-rh > 1)
	{
		if(diff_high(x->left) >= 1)
		{
			//	情况1	右旋
			x = right_rotate(x);
		}
		else
		{
			//	情况3 先左旋 再右旋
			x->left = left_rotate(x->left);
			x = right_rotate(x);
		}
	}
	else if(rh-lh > 1)
	{
		if(diff_high(x->right) >= 1)
		{
			//	情况4	先右旋 再左旋
			x->right = right_rotate(x->right);
			x = left_rotate(x);
		}
		else
		{
			//	情况2	左旋
			x = left_rotate(x);
		}
	}
	return x;
}

//添加 有序且平衡 返回root 可能会变化也可能不变 优点不用传二级指针
TreeNode* insert_tree(TreeNode* root,int data)
{
	//	按有序添加节点
	if(NULL == root)
		return create_node(data);
	
	if(root->data > data)
		root->left = insert_tree(root->left,data);
	else
		root->right = insert_tree(root->right,data);
	
	//	自动调成平衡
	root = auto_balance(root);
	return root;
}

//	前
void dlr_show(TreeNode* root)
{
	if(NULL == root) return;
	printf("%d ",root->data);
	dlr_show(root->left);
	dlr_show(root->right);
}

//	中序
void ldr_show(TreeNode* root)
{
	if(NULL == root) return;
	ldr_show(root->left);
	printf("%d ",root->data);
	ldr_show(root->right);
}

/*
	删除节点：
	1、待删除的是叶子节点，直接删除，重新调整
	2、待删除的节点度为1，使用非空子树替换，重新调整
	3、待删除的节点度为2,根据左右子树高度，选择高的分支，如果左子树高选择最大节点，如果右子树高选择最小节点替换，重新调整
*/

TreeNode* max_tree_node(TreeNode* root)
{
	if(NULL == root) return NULL;
	TreeNode* max = root;	
	while(max->right) max = max->right;
	return max;
}

TreeNode* min_tree_node(TreeNode* root)
{
	if(NULL == root) return NULL;
	TreeNode* min = root;
	while(min->left) min = min->left;
	return min;
}

TreeNode* del_tree(TreeNode* root,int data)
{
	if(NULL == root) return NULL;

	if(data == root->data)
	{
		if(NULL == root->left && NULL == root->right)
		{
			free(root);
			return NULL;
		}
		if(NULL == root->left)
		{
			//	左空 替换成右
			TreeNode* temp = root->right;
			free(root);
			return temp;
		}
		if(NULL == root->right)
		{
			//	右空 替换成左
			TreeNode* temp = root->left;
			free(root);
			return temp;
		}

		//	左右非空
		int lh = high_tree(root->left);
		int rh = high_tree(root->right);
		if(lh >= rh)
		{
			//	找左子树最大节点替换
			TreeNode* max_node = max_tree_node(root->left);
			root->data = max_node->data;
			root->left = del_tree(root->left,root->data);
		}
		else
		{
			//	找右子树最小节点替换	
			TreeNode* min_node = min_tree_node(root->right);
			root->data = min_node->data;
			root->right = del_tree(root->right,root->data);
		}
		return root;
	}

	if(data < root->data)
		root->left = del_tree(root->left,data);
	else
		root->right = del_tree(root->right,data);
	
	root = auto_balance(root);
	return root;
}

int main(int argc,const char* argv[])
{
	TreeNode* root = NULL;
	for(int i=0; i<10; i++)
	{
		root = insert_tree(root,i+1);	
	}

	root = del_tree(root,4);
	root = del_tree(root,5);
	root = del_tree(root,6);

	dlr_show(root);
	printf("\n");
	ldr_show(root);
}

一根葱230
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树、平衡二叉树、堆和优先队列
02-24
在数据结构中，二叉树、平衡二叉树、堆和优先队列都是非常重要的概念和数据结构。通过了解它们的基本概念和操作，我们可以更好地应用它们解决实际问题。同时，掌握这些数据结构的实现原理和时间复杂度也是很重要的，...
堆
gls_nuaa的博客
03-19 1385
数据结构——堆       相较于其他数据结构，堆是新接触到的。那么就在今天仔细地研究一下。       什么是堆？堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象（节选自百度百科）。简单点看，堆也是二叉树的一种。分为大顶堆（父...
数据结构-非线性结构-树形结构：有序树 -＞二叉树 -＞ 平衡二叉树（任何节点的左右子树的高度差不大于1）-＞ 完全二叉树（除最底层外的其他层都被填满，且最底层左到右填入） -＞ 堆（优先队列）
u013250861的博客
05-03 537
完全二叉树：即除了最底层，其他层的节点都被元素填满，且最底层左到右填入。完全二叉树属于平衡二叉树。堆是一种完全二叉树，且满足以下条件： 我们对堆中的结点按层进行编号，可以将堆逻辑结构映射到数组中add、extractMax操作的时间复杂度都是 O(logn)O(logn)O(logn) 由上图可知，二叉堆可以用动态数组来实现。 MyArray.java 1、最大堆 MaxHeap.java 2、最小堆 MinHeap.java 三、heapify：将任意数组整理成堆的形状 Queue.java Prio
树型结构总结：二叉查找树、堆、平衡树、2-3查找树、红黑树、B树、B+树
cyc头发还挺多的博客
03-28 1554
树型结构总结：二叉查找树、堆、平衡树、2-3查找树、红黑树、B树、B+树 面试题： 1、TreeMap、TreeSet、HashMap底层实现中为什么使用红黑树？为什么不用二叉查找树？为什么不使用平衡树？ 2、文件系统为什么要用B树而不用二叉查找树或者哈希表？ 3、为什么B+树在数据库用的多（Mysql底层是B+树），不用B树或者哈希表？ ...
数据结构——二叉树篇（二叉搜索树、平衡二叉树、堆、哈夫曼树）
m0_66881249的博客
11-27 543
数据结构二叉树知识及相关代码
平衡二叉树的基本操作
07-18
总结，平衡二叉树的基本操作包括插入、删除和修改，这些操作都需要保证树的平衡性以维持高效性能。不同的平衡二叉树类型有不同的特性，适用于不同的应用场景。掌握平衡二叉树的操作方法，对于理解和实现高效的数据...
树和二叉树
03-16
二叉树有多种变种，如满二叉树、完全二叉树、平衡二叉树（如AVL树和红黑树），每种都有其特定的性质和用途。 在实际应用中，二叉搜索树允许快速查找、插入和删除操作，而平衡二叉树则保证了操作的时间复杂度不会因...
二叉树建立和查找 数据结构
06-22
在计算机科学领域，数据结构是组织和管理大量...通过实践这些基本操作，你可以进一步探索更高级的主题，如平衡二叉树（AVL树、红黑树）、二叉堆、B树和B+树等，这些都广泛应用于数据库索引、优先队列和文件系统等领域。
第六章 树和二叉树作业及答案（100分）.docx
09-21
平衡二叉树 B. 二叉排序树 C. 堆 D. 哈夫曼树 10．某二叉树的中序遍历序列和后序遍历序列正好相反，则该二叉树一定是（ ）的二叉树。 A．空或只有一个结点 B．高度等于其结点数 C．任一结点无左孩子 D．任一结点无...
二叉树中完全二叉树、满二叉树、二叉排序树、平衡二叉树的区别和联系
zlhzlh11的专栏
07-18 4495
1，完全二叉树： 只有最下面的两层结点度小于2，并且最下面一层的结点都集中在该层最左边的若干位置。 2，满二叉树： 是一颗完全二叉树； 除了叶结点外每一个结点都有左右子叶且叶结点都处在最底层。深度为k，且有2的(k)次方－1个节点。 3，堆： 是一颗完全二叉树； 大根堆：左右子树的结点值都小于根结点值，左右子树都是大根堆。 小根堆：左右子树的结点值都大于根结点值，左
数据结构__堆
mw_nice的博客
02-27 623
堆就是用数组实现的二叉树，所有它没有使用父指针或者子指针。堆根据“堆属性”来排序，“堆属性”决定了树中节点的位置。 堆的常用方法： 构建优先队列 支持堆排序 快速找出一个集合中的最小值（或者最大值） 在朋友面前装逼 堆属性 堆分为两种：最大堆和最小堆，两者的差别在于节点的排序方式。 在最大堆中，父节点的值比每一个子节点的值都要大。在最小堆中，父节点的值比每一个子节点的值都要小。这就是...
堆一定是完全二叉树_本周小结！（二叉树系列四）
weixin_39954908的博客
12-06 594
给「代码随想录」一个星标吧！❝这已经是二叉树的第四周总结了，二叉树是非常重要的数据结构，也是面试中的常客，所以有必要一步一步帮助大家彻底掌握二叉树！❞周一在二叉树：合并两个二叉树中讲解了如何合并两个二叉树，平时我们都习惯了操作一个二叉树，一起操作两个树可能还有点陌生。其实套路是一样，只不过一起操作两个树的指针，我们之前讲过求 二叉树：我对称么？的时候，已经初步涉及到了 一起遍历两颗二叉树...
数据结构-二叉树（基础知识）
abcnull 的博客
02-22 1191
二叉树关键名词 结点的度：结点拥有几个直接子树，那它的度就是几 树的度：树内各结点度的最大值 叶子结点：度为 0 的结点 非终端结点：度不为 0 的结点 孩子结点：原结点的子树的根结点被称为原结点孩子 双亲结点：原结点是其子树根结点的双亲 兄弟结点：同一个双亲的孩子结点之间互为兄弟结点 祖先结点：该结点往上经过根结点的那些结点成为祖先结点 子孙结点：类比祖先结点 层次：根在第一层，下面一次加一 ...
二叉树、平衡二叉树、完全二叉树、满二叉树
varyall的专栏
11-10 932
基本概念 结点的层次（Level）从根开始定义，根为第一层，根的孩子为第二层。 二叉树的高度：树中结点的最大层次称为树的深度（Depth）或高度。         二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆。二叉树的每个结点至多只有二棵子树(不存在度大于2的结
堆和平衡树
沙茶酱的代码库>__<
11-16 476
堆 维护一棵完全二叉树 找最值可看成O（1），找其他元素只能一个个遍历平衡树 是一种二叉排序树 二叉排序树是一种比较有用的折衷方案。 数组的搜索比较方便，可以直接用下标，但删除或者插入某些元素就比较麻烦。 链表与之相反，删除和插入元素很快，但查找很慢。 二叉排序树就既有链表的好处，也有数组的好处。 在处理大批量的动态的数据是比较有用。将查找的时间复杂度保证在O(logN)范围内。
搜索二叉树，平衡二叉树，堆三者插入删除操作分析总结
markconca的博客
12-22 1211
引言：搜索二叉树，平衡二叉树，堆三者插入删除操作在选择题中经常出现，很容易混淆 所以在这里就简单总结一下： 一.搜索二叉树 定义：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左...
最大堆和最小堆和平衡二叉树_最小堆二叉树
从零开始的教程世界
07-21 2158
最大堆和最小堆和平衡二叉树A Min Heap Binary Tree is a Binary Tree where the root node has the minimum key in the tree. 最小堆二叉树是二叉树，其中根节点在树中具有最小密钥。 The above definition holds true for all sub-trees in the tree. Thi...
数据结构--堆
qq_turn
06-12 2556
第十一章 22题 // An highlighted block var foo = 'bar';
左式堆是平衡二叉树吗
最新发布
06-11
关于平衡性，左式堆（大顶堆）本身并不是一种平衡二叉树，如红黑树、AVL树或B树那样，它们旨在保持树的高度尽量平衡以支持高效的搜索和插入操作。左式堆的主要关注点在于堆的特性而非平衡，它的高度可能会随着插入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值