手撕排序之堆排序

一、概念：

什么是逻辑结构、物理结构？

逻辑结构：是我们自己想象出来的，就像内存中不存在一个真正的树

物理结构(存储结构)：实际上在内存中存储的形式。

堆的逻辑结构是一颗完全二叉树

堆的物理结构是一个数组

之前讲过二叉树可以用两种结构进行表示。

第一种就是链式结构，将一个一个结点进行链接。

第二种就是用数组表示。

数组表示意味着我们就是以数组为结构进行访问，但我们可以通过父子结点的下标关系将其看成树。

下面是孩子与结点的下标关系（需要记住！）

、

思路：

我们将数组想象成一个完全二叉树------首先第一个表示树的根，接下来两个表示根的两个孩子，数组的下面4个表示树的两个孩子的下面一层，以此类推。最后一层不满，前面的都是连续的。

但是进行了上面的步骤后，还是不能将其称为堆。

堆分为两类：

• 大顶堆（大根堆）：树中所有的父亲都大于等于孩子
• 小顶堆（小根堆）：树中所有的父亲都小于等于孩子

一道经典例题（判断一串数字是否是堆）

解题方法：

将第一个数字看作二叉树的根，再往后取两个数字当作根的左右孩子，接着再取4个数，以此类推。直至还原成一个完全二叉树，接着看是不是属于堆的两种类型，如果既不是大顶堆，也不是小顶堆，那么这一串数字就不是堆。

堆的插入：

首先堆在逻辑结构上是一颗二叉树，但逻辑结构是我们自己想象出来的，本质上数据还是存储在数组中，所以我们应该对数组进行修改。

这里的插入我们选择尾插，尾插后有一下几种情况：

1、

直接尾插，不用改变任何顺序

2、

发现尾插顺序不满足大堆或者小堆，记住插入只影响自己的祖先，与其他的祖先没有关系！

所以我们只要改变孩子与祖先的关系，如何根据孩子找到父亲的下标呢？

parent = （child-1）/ 2 即可。

将这两个位置进行交换。

3、最坏的情况

最坏情况下可能会一直到根节点

因此每次交换完，都要进行孩子与父亲的比较。

时间复杂度：

我们看最坏的情况，执行次数就是树的高度次，也就是O（logN）.

原码：

Swap(HeapDataType* a, HeapDataType* b)
{
	HeapDataType tmp = *a;
	*a = *b;
	*b = tmp;
}

void AdujstUp(HeapDataType* 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 HeapPush(HP* php,HeapDataType x)
{
	assert(php);
	//判断是否需要扩容
	if (php->capcity == php->size)
	{
		int newCapcity = php->capcity == 0 ? 4 : php->capcity * 2;
		//注意realloc的使用方法
		HeapDataType* tmp = (HeapDataType*)realloc(php->a, sizeof(HeapDataType) * newCapcity);
		if (tmp == NULL)
		{
			perror(realloc);
			exit(-1);
		}
		php->a = tmp;
		php->capcity = newCapcity;
	}
	php->a[php->size] = x;
	php->size++;
	//向上调整算法，跟祖先进行比较
	AdujstUp(php->a, php->size-1);
}

堆的删除：

首先我们需要明确针对堆的删除，我们需要删除的是堆的根节点。

思路一（错误）

我们直接将数组的首元素删除，然后移动（memmove）后面的数据内容，但这样极大可能影响了大小堆的结构！

思路二：（向下调整算法）

我们直接将数组的首元素和数组的最后一个元素交换位置，然后size--，删除最后一个元素，也就是根节点。

这时候我们发现根节点的左右子树都是大堆/小堆

然后将根节点与左右节点的较小结点进行比较，如果还小，那么继续交换，直到叶节点为止

以此类推，堆顶的元素是最小的，继续pop，那么次小的元素又到堆顶......

原码：

void AjustDown(HeapDataType* a,int n,int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//确定最小孩子
		if (child + 1 < n && a[child] < a[child + 1])//防止只有左叶子，访问右叶子会越界
			child++;
		if (a[parent] < a[child])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}

void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);
	Swap(&php->a[0], &php->a[php->size - 1]);
	php->size--;
	AjustDown(php->a,php->size,0);
}

小总结：（调整算法的前提）

向上调整算法的前提是：前面的数据内容都是大堆/小堆

向下调整算法的前提是：左右子树的数据内容都是大堆/小堆

TIP：

我们可以根据这个思路，可以实现一个排序算法，也就是堆排序。

时间复杂度：

跟插入一样，都是O（logN）。

堆排序：

1、建堆：

我们可以直接用向上寻找算法进行建堆。------为什么？

建堆有两种方式：

第一种就是向上建堆。

利用向上调整算法，每一个插入然后进行向上调整，完成建堆

时间复杂度：O(N) = N*logN

解析：

我们采取最差情况，得到O(h)的表达式，然后再用等式将h替换成n

总体的时间复杂度是O(N) = N*logN

第二种就是向下建堆。

从倒数第一个非叶子结点开始跳（也就是最后一个结点的父亲）

时间复杂度：O(N)

解析：

先假设h是树的高度，N是结点的个数

我们先用树的高度h作为自变量便于计算。最后再用等式进行替换。

考虑最坏的情况：

每层数据的个数 * 向下移动的层数

然后是等差*等比的数列求和，我们采用错位相减法计算。

最后的计算结果是2^h - 1- h.

因为2^h - 1 = n.

所以O(N) = N - log(N+1)

为什么向下调整算法要比向上调整复杂度低呢？

因为向下调整层数越低，向下调整的次数越多，所以是低*高

而向上调整层数越高，向上调整的次数就越多，所以是高*高，并且层数越高，占比越大，最后一层的结点个数就占了50%。

最后一层结点个数多并且向上调整的次数也多！

2、排序

如果我们排升序，建大堆。

排降序，建小堆。

原因：

建小堆有可能关系全乱了，剩下数据，看成新的完全二叉树，不一定是堆，重新建堆代价太大！

例子：

建大堆：

堆顶跟最后一个位置交换，最大的数据排好了，然后将最后一个元素不列入排序，剩下元素除了根节点其余是堆。剩下的数据由堆顶元素进行向下调整算法，选出次大的，代价是logN。

注意向上调整算法和向下调整算法的前提都是保证数据是堆！

以下是建小堆的堆排序算法

所以一共的时间复杂度O(N) = N*logN.

原码：

void HeapSort(int* a, int n)
{
	//建堆
	//建小堆/大堆

	//向上调整建堆
	//O(N*logN)
	/*for (int i = 1; i < n; i++)
	{
		AdujstUp(a, i);
	}*/
	//向下调整建堆
	//O(N)，效率比向上调整高
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//注意这里的n是数据个数，而公式中的n是下标
	{
		AjustDown(a, n, i);
	}
	//根节点的值要么最大，要么最小，可以进行排序
	//这一部分的时间复杂度O(N) = N*logN
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AjustDown(a, end, 0);
		end--;
	}
}