一键难忘520

这个屌丝很懒，什么也没留下！

热门标签

【数据结构】二叉树-堆

作者：一键难忘520 | 2024-06-21 22:18:43

踩

【数据结构】二叉树-堆

一.树概念及性质

树是一种非线性的数据结构，它是由数个节点组成的具有层次关系的集合。之所以叫做树，是因为长得就像一颗倒挂的树。就像下图一样，数据结构中的树是‘根’朝上，‘叶’朝下的。

树的结构从一个特殊的节点出发：根节点，该节点没有任何的前驱节点，其余节点都是由此根节点延伸而来。

一棵树可以进行拆分为根节点和子树，如上图，第一个根节点下有三个子树，而每个子树又可以继续拆分为根节点和子树，直到某个根节点没有子树为止，从这个角度来看，树是递归定义的。

注意：树形结构中，子树之间不能有交集，否则就不是树形结构。

了解树的基本概念后，接下来就以这幅图来讲解树中的一些常见概念

节点的度：一个节点含有的子树的个数称为该节点的度，例如图中A的度为6

树的度：一棵树中，最大的节点的度，例如图中树的度为6

叶节点：度为0的节点称为叶节点，例如图中的B、C、H、I......

分支节点：度不为0的节点，例如图中：D、E、F、G......

父节点：一个节点含有子节点，则该节点为子节点的父节点，例如：D是H的父节点

子节点：与父节点相对，例如：H是D的子节点

二.二叉树的概念与实现

二叉树是树的一种，满足以下定义：

1.二叉树不存在度大于2的节点

2.二叉树的子树有左右之分，次序不能进行颠倒，二叉树是有序树

同样，二叉树也具有特殊形态，那就是完全二叉树和满二叉树。

完全二叉树：每一层的节点填满以后再进行下一层填入，且每层的填入都是从左到右依次进行，这是一种相当有序的存在，是效率很高的数据结构。

满二叉树：特殊的完全的二叉树，每一层的节点个数都达到最大值。

二叉树具有的性质（规定根节点的层数为1）：

1.一颗非空二叉树的第n层上最多具有2^(n-1)个节点

2.深度为h的二叉树的最大节点个数为2^h-1

3.对于任何一个二叉树，度为0的节点个数（N0）等于度为2节点个数（N2）加1，即：N0=N2+1

4.对于下标为i的节点，它的父节点下标为(i-1)/2，它的左孩子下标为2i+1，右孩子为2i+2(如果存在的话）

二叉树的存储结构可以分为顺序结构和链式结构，但是此处我们只讨论顺序结构，使用顺序结构来实现堆。如下图所示，使用顺序结构（数组）储存二叉树适合于完全二叉树，否则会造成数组空间的浪费。

三.堆的概念和结构

堆满足以下定义：

1.堆总是一颗完全二叉树

2.堆中的某个节点的值总是不大于或不小于其父节点的值

如下图所示：就是典型的大堆和小堆，但需要注意一点：大堆在储存在数组中不一定是降序排列，因为左右孩子节点的大小并没有关系，例如下图中80的左右孩子节点可以交换，同样满足大堆，但就不符合升序了，小堆也是同理。

四.堆的实现

1.向下调整算法

向下调整算法有一个前提：左右子树必须是一个堆。

如下图所示，除了根节点27以外，左右子树都是小堆，那么只需要将27进行向下调整就能使整个二叉树称为堆的结构。如何进行调整？要调整为小堆，27需要和左右孩子中较小的一个进行比较，图中是15，因此27需要先和15进行交换，这样才能满足小堆的结构，但是这还不够，27还要再向下一层进行比较调整，直到找到合适位置或称为叶节点。下图展现了整个过程：

以下是向下调整算法的代码实现，其中a是堆的数组实现，n是数组大小，parent是调整开始的节点，即父节点，根据二叉树性质得到其左孩子为：parent*2+1，但可能还有另外一个右孩子且大小不确定，因此进行判断，后续进行循环判断交换即可。


void AdjustDown(HPDatatype* a, int n, int parent)
{
	int child = parent * 2 + 1;
 
    //找出孩子节点中大的一个(建大堆）
	if (child + 1 < n && a[child] > a[child + 1])
	{
		child++;
	}
    
    //直到超出数组范围n为止
	while (child < n)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

2. 堆的创建

有了向下调整算法，就下来就能进行建堆了。给定一个数组，不妨将其想象为一个二叉树的结构，要想使整个树成为堆，自然需要调整。如何调整？向下调整需要左右子树为堆的前提，在一个乱序的树中怎么找到堆？这里不妨直接将叶节点看作一个已经建立好的堆，单个的叶节点没有调整的必要，那么从叶节点的父节点开始调整，这样就能建成一个堆，如图中（5,10,11），随后从4开始调整，又有了（4,8,9）这一个堆，有了这两个堆，就又可以从2开始调整，这样（2,4,5,8,9,10,11）都是一个堆了，如此循环往复，最终就能将一个无序的数组调整为一个堆了。

向下调整建堆非常简单，就是在向下调整算法中加个循环而已，不过需要强调，叶节点不需要进行向下调整，因此起点从最后一个节点的父节点开始即可（上图右体现），那么最后此处k-1是最后一个节点的下标，再-1进行/2就是得到其父节点，随后往后挨个进行调整即可。


//向下调整建堆，k是数组大小
for (int i = (k - 1 - 1) / 2; i < k; i++)
{
	AdjustDown(a, k, i);
}

3.向上调整算法

如果要向一个堆进行插入数据，此时就需要向上调整算法，此时只需要不断找到父节点进行比较即可，终止条件是找到最顶层的根节点比较后。


//向上调整算法
void AdjustUp(HPDatatype* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

4.堆的删除

删除堆的最后一个节点十分简单，直接删除该数据（让size--）即可。此处讨论的是删除根节点，删除后仍要使剩余数据成为堆。难点在于，如果直接删除根节点，其余节点前移，这样就会破坏原有的关系，原本的孩子节点可能就突然成为跟原本父节点同一层的了，关系全部就打乱了，再恢复就会很麻烦。

那么使用向下调整就会很轻松，交换最后一个节点和根节点，删除最后一个节点，现在的新根节点就是原本的最后一个节点，此时其余的关系仍然不变，即新根节点的左右都是堆的结构，满足向下调整的前提，那么执行向下调整算法一次，就能使成为新的堆。

五.堆排序

利用堆来进行排序分为两步：

1.利用向下调整进行建堆，其中排升序就建大堆，排降序就建小堆

2.利用堆删除的思想，将堆顶数据（最大或最小）与最后进行交换，再进行向下调整（除开最后一个已经是最大/最小的数据），这样下一次的堆顶就是第二大/第二小的数据了，反复进行就能排升序/降序了


void HeapSort(int* a, int n)
{
	//倒序：建小堆
 
	//向下调整建堆
	//从最后一个节点（n-1)的父节点开始
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
 
 
	//n-1是最后一个元素的下标
	int end = n - 1;
	while (end > 0)
	{
		//此时a[0]最小，放最后，再调整又成新的小堆，a[0]成第二小的
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

六.堆-源码

头文件：Heap.h


#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
 
typedef int HPDatatype;
typedef struct Heap
{
	HPDatatype* a;
	int size;
	int capacity;
}HP;
 
void HPInit(HP* php);
void HPDestroy(HP* php);
void HPPush(HP* php, HPDatatype x);
void HPPop(HP* php);
HPDatatype HPTop(HP* php);
int HPEmpty(HP* php);
int HPSize(HP* php);
 
void swap(HPDatatype* p1, HPDatatype* p2);
void HeapSort(int* a, int n);

源文件：Heap.c


#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
 
void HPInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->capacity = php->size = 0;
}
 
void HPDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}
 
void swap(HPDatatype* p1, HPDatatype* p2)
{
	HPDatatype tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
void AdjustUp(HPDatatype* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
 
void HPPush(HP* php, HPDatatype x)
{
	assert(php);
	//扩容
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDatatype* tmp = (HPDatatype*)realloc(php->a, sizeof(HPDatatype) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
 
	php->a[php->size] = x;
	php->size++;
 
	AdjustUp(php->a, php->size - 1);
}
 
//n是元素个数，即最大访问到n-1
void AdjustDown(HPDatatype* a, int n, int parent)
{
	int child = parent / 2 + 1;
	while (child < n)
	{
		//child+1可能造成数组越界访问
		//只有一个左孩子就不进行++
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child++;
		}
		if (a[parent] > a[child])
		{
			swap(&a[parent], &a[child]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
 
void HPPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	swap(&php->a[0], &php->a[php->size-1]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}
 
HPDatatype HPTop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	return php->a[0];
}
 
int HPEmpty(HP* php)
{
	assert(php);
	return (php->size == 0);
}
 
int HPSize(HP* php)
{
	assert(php);
	return php->size;
}
 
void HeapSort(int* a, int n)
{
	//倒序：建小堆
	//向上调整建堆:相当于一个个进行插入
	/*for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}*/
 
	//向下调整建堆
	//从最后一个节点（n-1)的父节点开始
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
 
 
	//n-1是最后一个元素的下标
	int end = n - 1;
	while (end > 0)
	{
		//此时a[0]最小，放最后，再调整又成新的小堆，a[0]成第二小的
		swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

源文件:Test.c


#define _CRT_SECURE_NO_WARNINGS 1
#include"Heap.h"
 
void testHeap()
{
	int a[] = { 4,6,7,8,9,1,2,3 };
	HP hp;
	HPInit(&hp);
	for (int i = 0; i < sizeof(a)/sizeof(int); i++)
	{
		HPPush(&hp, a[i]);
	}
 
	HPPop(&hp);
	HPPop(&hp);
 
	HPDestroy(&hp);
}
void testHeapsort()
{
	int a[] = { 4,5,6,7,1,2,3,9,8 };
	HeapSort(a, sizeof(a) / sizeof(a[0]));
 
}
 
 
int main()
{
	//testHeap();
	testHeapsort();
 
 
	return 0;
}

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】