堆排序

1: 先将待排序的数视作完全二叉树(按层次遍历顺序进行编号, 从0开始)，如下图:

2：完全二叉树的最后一个非叶子节点，也就是最后一个节点的父节点。最后一个节点的索引为数组长度len-1，那么最后一个非叶子节点的索引应该是为(len-1)/2.也就是从索引为2的节点开始，如果其子节点的值大于其本身的值。则把他和较大子节点进行交换，即将索引2处节点和索引5处元素交换。交换后的结果如图：

建堆从最后一个非叶子节点开始即可

3：向前处理前一个节点，也就是处理索引为1的节点，此时79>30,79>58,因此无需交换。

4：向前处理前一个节点，也就是处理索引为0的节点，此时9 < 79,9 < 49, 因此需交换。应该拿索引为0的节点与索引为1的节点交换，因为79>49. 如图:

5：如果某个节点和它的某个子节点交换后，该子节点又有子节点，系统还需要再次对该子节点进行判断。如上图因为1处，3处，4处中，1处的值大于3,4出的值，所以还需交换。

牢记： 将每次堆排序得到的最大元素与当前规模的数组最后一个元素交换。

代码实现：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdlib>
using namespace std;

void adjust(int arr[], int len, int index)
{
    int left = 2*index + 1;
    int right = 2*index + 2;
    int maxIdx = index;
    if(left<len && arr[left] > arr[maxIdx]) maxIdx = left;
    if(right<len && arr[right] > arr[maxIdx]) maxIdx = right; 
     //这个很重要，maxInx是取三个数的最大值与index节点交换
     // maxIdx是3个数中最大数的下标
    if(maxIdx != index)                 // 如果maxIdx的值有更新
    {
        swap(arr[maxIdx], arr[index]);
        adjust(arr, len, maxIdx);       // 递归调整其他不满足堆性质的部分
    }

}
void heapSort(int arr[], int size)
{
//初始化堆
    for(int i=size/2 - 1; i >= 0; i--)  // 对每一个非叶结点进行堆调整(从最后一个非叶结点开始)
    {
        adjust(arr, size, i);
    }
    for(int i = size - 1; i >= 1; i--)
    {
        swap(arr[0], arr[i]);           // 将当前最大的放置到数组末尾
        adjust(arr, i, 0);              // 将未完成排序的部分继续进行堆排序
    }
}

int main()
{
    int array[8] = {8, 1, 14, 3, 21, 5, 7, 10};
    heapSort(array, 8);
    return 0;
}

数据结构上的非递归版的堆排序：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 10005;
void HeapAdjust(int a[],int s,int m)
{
    int rc = a[s];
    for(int i =  2 * s;i <= m;i *= 2)
    {
        if(i < m && a[i] < a[i + 1]) i++;
        if(a[i] <= rc) break;
        a[s] = a[i];
        s = i;
    }
    a[s] = rc;
}
void Swap(int a[],int i,int j)
{
    a[i] = a[i] + a[j];
    a[j] = a[i] - a[j];
    a[i] = a[i] - a[j];
}
void HeapSort(int a[],int n)
{
    //初始化
    for(int i = n / 2;i >= 1;--i)//从分支节点开始调整，跳过叶子节点
    {
        HeapAdjust(a,i,n);
    }
    for(int i = n;i > 1;--i)
    {
        Swap(a,1,i);
        HeapAdjust(a,1,i - 1);
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    int a[N];
    for(int i = 1;i <= n;++i)
    {
        scanf("%d",&a[i]);
    }
    HeapSort(a,n);
    for(int i = 1;i <= n;++i)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    return 0;
}