常用排序之堆排序法

        什么是堆？堆实际上是一棵完全二叉树，堆分为大顶堆和小顶堆，大顶堆的堆顶的关键字是最大的，小顶堆的堆顶的关键字是最小的。

堆排序思想：利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性。

一般用数组来表示堆，如下所示：

堆的操作

insert (插入)

       为将一个元素X插入到堆中，我们在下一个空闲位置创建一个空穴，否则该堆将不是完全树。如果X可以放在该空穴中而不破坏堆的序，那么插入完成。否则，我们把空穴的父节点上的元素移入该穴中，这样，空穴就朝着根的方向上行一步。继续该过程直到X能被放入空穴中为止。这种一般的策略叫做上滤，新元素在堆中上滤直到找出正确的位置。

//  新加入i结点  其父结点为(i - 1) / 2  
void  heap_insert(int a[], int i)  
{  
    int j, temp;  
    temp = a[i];  
    j = (i - 1) / 2;         //父结点  
    while (j >= 0 && i != 0)  
    {  
        if (a[j] <= temp)  
            break;  
        a[i] = a[j];         //把较大的子结点往下移动,替换它的子结点  
        i = j;  
        j = (i - 1) / 2;  
    }  
    a[i] = temp;  
}  

DeleteMin (删除最小元)

       删除一个最小元，在根节点处产生了一个空穴。由于现在堆少了一个元素，因此堆中最后一个元素X必须移动到该堆的某个地方。如果X可以被放到空穴中，那么DeleteMin完成。不过这一般不太可能，因此我们将空穴的两个儿子中较小者移入空穴，这样就把空穴向下推了一层。重复该步骤知道X可以被放入空穴中。因此，我们的作法是将X置入沿着从根开始包含最小儿子的一条路径上的一个正确的位置。

//  从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2  
void percdown(int a[], int i, int n)  
{  
    int j, temp;  
    temp = a[i];  
    j = 2 * i + 1;  
    while (j < n)  
    {  
        if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的  
            j++;  
  
        if (a[j] >= temp)  
            break;  
  
        a[i] = a[j];     //把较小的子结点往上移动,替换它的父结点  
        i = j;  
        j = 2 * i + 1;  
    }  
    a[i] = temp;  
}  
//在最小堆中删除数  
void DeleteNumber(int a[], int n)  
{  
    swap(a[0], a[n - 1]);  
    percdon(a, 0, n - 1);  
}  

BuildHeap (构建堆)

BuildHeap操作把N个关键字作为输入并把它们放入空堆中。显然，这可以使用N个相继的

//构建堆
void buildHeap(int a[],int n)
{
   int i;
   for(i=n/2;i>=0;i--)
      percdown(a,i,n);
}

堆排序

        建立N个元素的二叉堆的基本方法，此时的花费是O(N)时间。然后我们执行N次DeleteMin操作。按照顺序，最小的元素先离开堆。通过将这些元素记录到第二个数组后再将数组拷贝回来，我们得到N个元素的排序。由于每个DeleteMin花费时间O(logN)，因此总的运行时间为O(N logN)。

       该算法的主要问题是它使用了一个附加的数组。因此，存储需求增加一倍。避免使用第二个数组的聪明做法是：在每次DeleteMin之后，堆缩小了1。因此，位于堆中最后的单元可以用来存放刚刚删去的元素。例如，设我们有一个堆，它包含有6个元素。第一次DeleteMin产生A1。现在该堆中只有5个元素，因此我们可以把A1放在位置6上。下一次DeleteMin产生个A2，由于该堆现在只有四个元素，因此我们把A2放在位置5上。

        现在将使用一个max堆。堆排序通过构建堆和堆调整两个过程来进行的：首先是根据元素构建堆。然后通过将堆中的最后 。元素与第一个元素交换，缩减堆的大小并进行下滤，来执行N-1次DeleteMax操作。当算法终止时，数组则以所排的顺序包含这些元素。

        堆排序过程的时间复杂度是O(N lgN)。因为建堆的时间复杂度是O(N)（调用一次）；调整堆的时间复杂度是lgN，调用了n-1次，所以堆排序的时间复杂度是O(N lgN)。

实现

#include<stdio.h>

void swap(int *x, int *y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}
int leftchild(int i)
{
	return 2 * i + 1;
}
void pecdown(int a[], int i, int n)
{
	int child, temp;
	for (temp = a[i];leftchild(i) < n;i = child)
	{
		child = 2 * i + 1;
		if (child != n - 1 && a[child + 1] > a[child])
			child++;
		if (temp < a[child])
			a[i] = a[child];
		else
			break;
	}
	a[i] = temp;
}
void HeapSort(int a[], int n)
{
	int i;
	for (i = n / 2;i >= 0;i--)//建立堆//
		pecdown(a,i,n);
	for (i = n - 1;i > 0;i--)
	{
		swap(&a[0], &a[i]);
		pecdown(a, 0, i);
	}
}

int main()
{
	int b[] = {142,543,123,65,453,879,572,434,111,242,811,102};
	HeapSort(b,12);
	for (auto c : b)
		cout << c << " ";
	system("pause");
	return 0;
}