目录
一.树概念及性质
树是一种非线性的数据结构，它是由数个节点组成的具有层次关系的集合。之所以叫做树，是因为长得就像一颗倒挂的树。就像下图一样，数据结构中的树是‘根’朝上，‘叶’朝下的。
树的结构从一个特殊的节点出发：根节点，该节点没有任何的前驱节点，其余节点都是由此根节点延伸而来。
一棵树可以进行拆分为根节点和子树，如上图，第一个根节点下有三个子树，而每个子树又可以继续拆分为根节点和子树，直到某个根节点没有子树为止，从这个角度来看，树是递归定义的。
注意：树形结构中，子树之间不能有交集，否则就不是树形结构。
了解树的基本概念后，接下来就以这幅图来讲解树中的一些常见概念
节点的度：一个节点含有的子树的个数称为该节点的度，例如图中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 >= 0; 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;
}
11万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
