堆排序详细过程

目录

1.建堆

1.1 向上调整的方式建立大堆，以数组 a {2,1,5,7,6,8,} 为例

1.2 向下调整的方式建立大堆

2.排序

3.完整代码

---

堆排序过程：1.建堆，2.排序。排升序建大堆（任意一个节点都大于其左右孩子），排降序建小堆（任意一个节点都小于其左右孩子）。

其中建堆的方式分为两种：向上调整建堆和向下调整建堆

1.建堆

1.1 向上调整的方式建立大堆，以数组 a {2,1,5,7,6,8,} 为例

 

首次接收child的下标为1，因为要通过child找到父亲节点下标0  (int parent = (child - 1) / 2;)

代码如下：

typedef int HPDataType;

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;
		}
	}
}

1.2 向下调整的方式建立大堆

第一次传最后一个节点的父亲节点下标：（n-1-1）/2

 代码如下

void AdjustDown(HPDataType* 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[child] > a[parent])   
		{
			Swap(&a[child], &a[parent]);

			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

2.排序

1.把堆顶的元素（也是最大的元素）与最后一个叶子节点交换，每一次确定一个元素的最终位置。

2.忽略最后一个元素（已经确定最终位置的元素），重新调整为大根堆。

3.重复1 2 直到队列有序。

int end = n - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		AdjustDown(a, end, 0); //仅对end个元素进行调整，忽略最后一个元素，因为已经有序
		end--;             //每排序一次，就确定一个元素最终位置
	}

3.完整代码

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


typedef int HPDataType;
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 AdjustDown(HPDataType* 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[child] > a[parent])    //'<'小堆，大于小于决定大堆小堆
		{
			Swap(&a[child], &a[parent]);

			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//升序建大堆，降序建小堆
void HeapSort(int* a, int n)
{
	int i = 0;
    //向上调整建堆
	//for (i = 1; i < n; i++)
	//{
	//	AdjustUp(a, i);  
	//					
	//}

	//向下调整建堆 
	for (i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

	//排序
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[end], &a[0]);
		AdjustDown(a, end, 0); 
		end--;  
	}
}

int main()
{
	int a[10] = { 2, 1, 5, 7, 6, 8 }; // 对数组排序
	HeapSort(a, 6);

	return 0;
}