堆排序---C语言实现

其他排序

基数排序
归并排序
插入排序和希尔排序
快速排序
冒泡排序和选择排序

堆排序

核心思想：利用了完全二叉树的思想(一个有n个结点的完全二叉树，其父结点 i 的范围为：0~$\frac{n}{2}$ - 1 左孩子：2*i+1 右孩子：2*i+2)，即有大堆：所有的父节点的值均大于孩子的值，最终建堆后堆顶则为最大值

小堆：所有的父节点的值均小于孩子的值，最终建堆后堆顶则为最小值

此例中基于大堆实现

实现过程：我们将来的数组视为一颗完全二叉树，如下图所示：
根据大堆的特点，我们首先应该建堆，而建堆的顺序则是由下往上，因此，我们先从最底层开始，由于父节点的范围是 0~$\frac{n}{2}$ - 1 ,有九个结点，则知$\frac{n}{2}$ = 3，即值为15所对应的结点，和实际情况一致；下面我们开始建堆，由于大堆是父节点的值总是大于孩子的值，因此我们首先找到孩子中的最大值，然后将孩子的最大值与父节点比较，如下图所示：
如上图所示，经过比较交换后，父节点20大于其左右孩子的值，下面依次再对剩下的进行建堆，如下图所示：
如上图所示，我们已经建堆到了堆顶，但是此时我们发现了一个问题，就是在我们对上一层进行调整的时候，会可能导致父节点再次小于孩子结点情况的出现，而我们最顶层恰恰就是这种情况，其实在对下面几层调整时也可能出现此种情况，只是我们上图没有体现出来。另外，我们也很容易察觉到，已经调整好的结点只有当父节点的值改变时才可能再次出现父节点的值小于孩子结点的值得情况，因此，我们可以知道当父亲的结点值改变时，我们需要再次对这条路径上的结点进行重新调整，调整过程如下图所示：

如上图所示，经过调整，我们已经建好了堆，并且我们很容易看出此时堆顶（即根节点）为最大值；我们此时将建好的堆的根节点与数组的“最后一个”结点的值进行交换，则就将最大值排到了数组最后，如下如所示：
由于已经将最大值29排到了最后，因此在下次排序的时候我们就不需要考虑已经排好序的数，这也是为什么上面的最后一个加了双引号，这里是相对最后的意思。另外，我们将堆顶元素与“最后一个”元素交换后，需要重新调整堆来满足堆的特点，调整过程如下：


堆调整完成，然后再次将堆顶元素与“最后一个”未排序的数交换，如下：

然后不考虑已经排好序的数，再次调整堆，重复上述过程，直至排好序…

代码实现

#include <stdio.h>

void Print(int arr[],int nLen)
{
	if(arr == NULL || nLen <= 0) return ;

	for(int i = 0;i < nLen; i++)
	{
		printf("%d\t",arr[i]);
	}
	printf("\n");
}
void Swap(int *a,int *b)
{
	*a = *a ^ *b;
	*b = *a ^ *b;
	*a = *a ^ *b;
}
void Adjust(int arr[],int nRoot,int nLen)
{
	if(arr == NULL || nLen <= 0) return;

	int nMax;
	while(nRoot < nLen/2 )
	{
		nMax = 2*nRoot + 1;
		//找出孩子的最大值
		if(arr[nMax] < arr[2*nRoot +2] && 2*nRoot+2 < nLen)
		{
			nMax = 2*nRoot+2;
		}
		//孩子的最大值与父亲比较
		if(arr[nMax] > arr[nRoot])
		{
			Swap(&arr[nMax],&arr[nRoot]);
			nRoot = nMax;
		}
		else
		{
			return;
		}
	}
}
void HeapSort(int arr[],int nLen)
{
	if(arr == NULL || nLen <= 0) return;

	//建堆
	int nMax;
	for(int i = nLen/2-1;i >= 0;i--)
	{
		//从底往上建堆
		Adjust(arr,i,nLen);
	}

	//堆顶与最后一个元素交换
	for(int i = 0;i < nLen-1;i++)
	{
		if(arr[0] != arr[nLen-1-i])
		Swap(&arr[0],&arr[nLen-1-i]);
		//调整
		Adjust(arr,0,nLen-1-i);
	}
}

int main()
{
	int arr[] = {56,4,8,1,9,45,87,43,89,90,435};
	HeapSort(arr,sizeof(arr)/sizeof(*arr));
	Print(arr,sizeof(arr)/sizeof(*arr));
	return 0;
}

最好时间复杂度：O(nlogn)

最坏时间复杂度：O(nlogn)

平均时间复杂度：O( nlogn）

空间复杂度：O(1)

稳定性：稳定

适用场合：数组量大且较无序

排序名称	最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性	适用场合
BubbleSort	O(n)	O(n2)	O(n2)	O(1)	稳定
SelectSort	O(n2)	O(n2)	O(n2)	O(1)	不稳定
InsertSort	O(n)	O(n2)	O(n2)	O(1)	稳定
ShellSort	O(n)	O(n1.3)	O(n2)	O((log2n)	不稳定
QuickSort	O(nlogn)	O(nlogn)	O(n2)	O(logn)~O(n)	不稳定
MergeSort	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
HeapSort	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	稳定
RadixSort					稳定