堆排序

思路：
　　1、将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
　　2、将堆顶元素与末尾元素交换，将最大元素”沉”到数组末端;
　　3、重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
例子：
第一步：做成大根堆

第二步和第三步：
沉底并调整：

源代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<assert.h>
//堆排序（非递归）
void Adjust(int *arr, int start,int end)//一次调整过程
{
    int tmp = arr[start];
    for (int i = 2 * start + 1;i <= end;i = 2 * i + 1)//父推子：n     2n+1    2n+2 
    {
        if (i < end && arr[i] < arr[i + 1])//当i<end,有右孩子
        {
            i++;//i存放最大值的下标
        }
        if (arr[i] > tmp)
        {
            arr[start] = arr[i];
            start = i;//start指向下一个父节点
        }
        else
        {
            break;
        }
    }
    arr[start] = tmp;
}
void Heap_Sort1(int *arr, int len)
{
    int begin;
    for (begin = (len - 1 - 1) / 2;begin >= 0;begin--)//子推父   n    （n-1）/2
    {
        Adjust(arr, begin, len - 1);
    }
    for (int i = 0;i < len - 1;++i)
    {
        int tmp = arr[0];
        arr[0] = arr[len - 1 - i];
        arr[len - 1 - i] = tmp;
        Adjust(arr, 0, len - 1 - i - 1);
    }
}
void Show(int *arr, int len)
{
    for (int i = 0;i < len;++i)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
int main()
{
    int arr[] = { 2,5,3,2,5,5,7,5,6 };
    int len = sizeof(arr) / sizeof(arr[0]);
    Show(arr, len);
    //Heap_Sort(arr,len);
    Heap_Sort1(arr, len);
    Show(arr, len);
    return 0;
}

递归实现：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<assert.h>
void Max_HeapFind(int  *arr, int len, int i)//找三个中最大的值的下标
{
    int father = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < len && arr[left] > arr[father])//有左孩子，且左孩子的值大于父节点的值
    {
        father = left;//将左孩子的下标赋给父节点的下标
    }
    if (right < len && arr[right] > arr[father])//有右孩子，且右孩子的值大于父节点的值
    {
        father = right;//将右孩子的下标赋给父节点的下标
    }
    if (father != i)//判断父节点的下标是否移动
    {
        int tmp = arr[father];
        arr[father] = arr[i];
        arr[i] = tmp;
        Max_HeapFind(arr, len, father);//递归，用交换后的孩子结点做父节点继续比较
    }
}
void Build_Heap(int  *arr, int len)//建立大根堆，arr[0]放的是最大值
{
    for (int i = (len-1)/2;i >= 0;i--)//子推父，len->(len-1)/2
    {
        Max_HeapFind(arr, len, i);//调用函数找三个中最大的值的下标
    }
}
void Heap_Sort(int  *arr, int len)
{
    Build_Heap(arr, len);//找到大根堆
    for (int i = len - 1;i >= 0;i--)//将arr[0]的值与最后的值交换
    {
        int tmp = arr[0];
        arr[0] = arr[i];
        arr[i] = tmp;
        Max_HeapFind(arr,i,0);//递归，每次从第一个开始调用
    }
}
void Show(int *arr, int len)
{
    for (int i = 0;i < len;++i)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
int main()
{
    int arr[] = { 2,5,3,2,5,5,7,5,6 };
    int len = sizeof(arr) / sizeof(arr[0]);
    Show(arr, len);
    //Heap_Sort(arr,len);
    Heap_Sort1(arr, len);
    Show(arr, len);
    return 0;
}

个人觉得，非递归算法精炼，有说服力，但是不好理解。递归很好理解，但代码可能比较冗余。