排序（三）堆排序、归并排序、快速排序

7、堆排序
堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构（通常堆是通过一维数组来实现的），并同时满足堆的性质：即子结点的键值总是小于（或者大于）它的父节点。

我们可以很容易的定义堆排序的过程：

1、创建一个堆
2、把堆顶元素(最大值)和堆尾元素互换
3、把堆的尺寸缩小1，并调用heapify(A, 0)从新的堆顶元素开始进行堆调整
4、重复步骤2，直到堆的尺寸为1
　　
堆排序的代码如下：

#include 

// 交换函数
void swap (int a[], int i, int j)
{
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

// 打印数组
void printA (int *a, int len)
{
    int i;
    for (i = 0; i < len; i++)
    {
        printf ("%4d", a[i]);
    }

    printf ("\n");
}

// a 代表一个数组
// i 代表要调整的结点的下标
// len  数组的长度
void heapify(int *a, int i, int len)
{
    int left = 2 * i + 1;     // 左孩子结点下标
    int right = 2 * i + 2;    // 右孩子结点下标
    int max = i;     // 三个节点中最大元素的下标

    if (left < len && a[left] > a[max])
        max = left;
    if (right < len && a[right] > a[max])
        max = right;

    if (max != i)   // 当前父节点不是所有结点中最大的元素，需要做调整
    {
        swap (a, i, max);
        heapify (a, max, len);   // 调整被交换的结点
    }
}

void heapSort (int *a, int len)
{
    // 建堆
    int i;
    for (i = len/2 - 1; i >= 0; i--)
    {
        heapify (a, i, len);
    }

    // 排序
    for (i = len-1; i > 0; i--)
    {
        swap (a, 0, i);       // 拿堆顶元素与队尾元素进行交换
        len--;                // 找到一个最大元素以后堆大小减1
        heapify (a, 0, len);  // 调整堆顶元素
    }
}

int main()
{
    int a[10] = {9,6,8,0,3,5,2,4,7,1};
    int len = sizeof(a) / sizeof(a[0]);

    heapSort(a, len);

    printA (a, len);

    return 0;
}

---

8、归并排序
归并排序是创建在归并操作上的一种有效的排序算法，效率为O(nlogn)，1945年由冯·诺伊曼首次提出。

归并排序的实现分为递归实现与非递归(迭代)实现。递归实现的归并排序是算法设计中分治策略的典型应用，我们将一个大问题分割成小问题分别解决，然后用所有小问题的答案来解决整个大问题。非递归(迭代)实现的归并排序首先进行是两两归并，然后四四归并，然后是八八归并，一直下去直到归并了整个数组。

归并排序算法主要依赖归并(Merge)操作。归并操作指的是将两个已经排序的序列合并成一个序列的操作，归并操作步骤如下：

1、申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2、设定两个指针，最初位置分别为两个已经排序序列的起始位置
3、比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4、重复步骤3直到某一指针到达序列尾
5、将另一序列剩下的所有元素直接复制到合并序列尾
　　
归并排序的代码如下：

#include 

// 打印数组
void printA (int *a, int len)
{
    int i;
    for (i = 0; i < len; i++)
    {
        printf ("%4d", a[i]);
    }

    printf ("\n");
}

// a 是数组  tmp  是缓冲区
void merge(int *a, int left, int mid, int right, int *tmp)
{
    int i = left;
    int j = mid + 1;
    int k = 0;

    while (i <= mid && j <= right)
    {
        if (a[i] > a[j])
            tmp[k++] = a[j++];
        else
            tmp[k++] = a[i++];
    }

    while (i <= mid)
        tmp[k++] = a[i++];

    while (j <= right)
        tmp[k++] = a[j++];

    k = 0;
    for (i = left; i <= right; i++)
    {
        a[i] = tmp[k++];
    }
}

void mergeSort(int *a, int left, int right, int *tmp)
{
    if (left >= right)
        return;

    int mid = (left + right)/2;
    mergeSort (a, left, mid, tmp);    // 对左边部分进行归并排序
    mergeSort (a, mid+1, right, tmp); // 对右边部分进行归并排序
    merge (a, left, mid, right, tmp); // 将将部分数据进行归并
}

int main()
{
    int a[10] = {9,6,8,0,3,1,2,4,7,5};
    int len = sizeof(a) / sizeof(a[0]);
    int tmp[10];
    mergeSort (a, 0, len-1, tmp);
    printA (a, len);

    return 0;
}

---

9、快速排序
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个元素要O(nlogn)次比较。在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(nlogn)算法更快，因为它的内部循环可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治策略(Divide and Conquer)来把一个序列分为两个子序列。步骤为：

1、从序列中挑出一个元素，作为”基准”(pivot).
2、把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。
3、对每个分区递归地进行步骤1~2，递归的结束条件是序列的大小是0或1，这时整体已经被排好序了。
　　
快速排序的代码如下：

#include 

// 交换函数
void swap (int a[], int i, int j)
{
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

// 打印数组
void printA (int *a, int len)
{
    int i;
    for (i = 0; i < len; i++)
    {
        printf ("%4d", a[i]);
    }

    printf ("\n");
}

// 分区操作，返回基准值的下标
int partition(int *a, int left, int right)
{
    int pivot = a[right];
    int index = left;   // 如果找到一个比基准值小的元素，与下标为index的元素交换
    int i;
    for (i = left; i < right; i++)
    {
        if (a[i] < pivot)
        {
            swap (a, i, index);
            index++;
        }
    }
    swap (a, index, right);

    return index;   // 基准值所在位置下标
}

void qSort(int *a, int left, int right)
{
    if (left < right)
    {
        int pivot = partition(a, left, right);  // 进行分区操作，找基准值下标
        qSort (a, left, pivot-1);     // 对左边部分进行快速排序
        qSort (a, pivot+1, right);    // 对右边部分进行快速排序    
    }
}

int main()
{
    int a[10] = {9,6,8,0,3,1,2,4,7,5};
    int len = sizeof(a) / sizeof(a[0]);

    qSort (a, 0, len-1);

    printA (a, len);

    return 0;
}

常用算法总结