排序算法---快速排序、堆排序、冒泡排序

1 快速排序

文章原地址：https://blog.csdn.net/morewindows/article/details/6684558
快速排序的平均时间复杂度是0(NlogN)，它采用了一种分治的策略，通常称其为分治法。该方法的基本思想是：

1. 先从数列中取出一个数作为基准数。
2. 分区：将大于等于这个数放到它的右边，小于它的数全放在它的左边
3. 再对左右区间进行快排

虽然快速排序称为分治法，但分治法这三个字显然无法很好概括快速排序的全部步骤，因此我对快速排序做了进一步的说明：挖坑填数+分治法。

以一个数组作为示例，取区间第一个数为基准数。

初始时，i = 0; j = 9; X = a[i] = 72

由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。

从j开始向前找一个比X小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++; 这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办了？简单，再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3]; j–;

数组变为：

i = 3; j = 7; X=72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;

从i开始向后找，当i=5时，由于i==j退出。

此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。依次类推。

代码实现

void quick_sort(int *arr,int l,int r)
{
    if(l<r)
    {   
        int i=l,j=r,x=arr[i];
        while(i<j)
        {
            /* 从右往左找小于x的值，找到之后，放到arr[i++] */
            while(i<j && arr[j]>=x)
            {
                j--;
            }
            if(i<j)
            {
                arr[i++]=arr[j];
            }
            /* 从左往右找大于等于x的值，找到之后，放到arr[j--] */
            while(i<j && arr[i]<x)
            {
                i++;
            }
            if(i<j)
            {
                arr[j--]=arr[i];
            }
        }
        /* 放x */
        arr[i]=x;
        /* 对x左右两个区间进行快排 */
        quick_sort(arr,l,i-1);
        quick_sort(arr,i+1,r);
    }
}

测试：

int main(void)
{
    int arr[]={72,6,57,88,60,42,83,73,48,85};
    quick_sort(arr,0,9);
    for(int i=0;i<10;i++)
    {
        printf("%d ",arr[i]);
    }
    return 0;
}

stdlib库快排

stdlib库提供了快排函数qsort

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))

• base是要排序的的数组
• nitems是数组中元素个数
• size是每个元素所占字节数
• compar是比较函数

#include <stdio.h>
#include <stdlib.h>

int cmp(void *a,void *b)
{
    return *(int *)a - *(int *)b;
}

int main(void)
{
    int arr[]={72,6,57,88,60,42,83,73,48,85};
    qsort(arr,10,sizeof(int),cmp);
    for(int i=0;i<10;i++)
    {
        printf("%d ",arr[i]);
    }
    return 0;
}

2 堆排序

文章原地址：https://www.cnblogs.com/lanhaicode/p/10546257.html
堆是一个完全二叉树，通俗的说，堆就是利用完全二叉树的结构来维护的一维数组。
按照堆的特点可以把堆分为大顶堆和小顶堆：

• 大顶堆：每个结点的值都大于等于其左右孩子的值
• 小顶堆：每个结点都小于等于其左右孩子的值。

在用一维数组描述的堆中，如果父结点的下标是i，则左孩子的结点的下标是2i+1，右孩子是2i+2；所以如果孩子结点的下标是i，则父结点的下标结点j是：

j = (i-1)/2	/* 整数相除，取整，相当于向下取整数 */

我们用简单的公式来描述一下堆的定义：

• 大顶堆：arr[i] >= arr[2*i+1] && arr[i] >= arr[2*i+2]
• 小顶堆：arr[i] <=arr[2*i+1] && arr[i] <= arr[2*i+2]

下面以大顶堆为例。

堆排序的基本思想

将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根结点，然后把根结点和最后一个结点（数组最后一个元素）交换位置，那么末尾元素此时就是最大元素了。

1. 先把n个元素的无序序列，构建成大顶堆
2. 将根结点与最后一个元素交换位置。（将最大元素放到数组末端）
3. 交换过后可能不再满足大顶堆的条件，所以需要将剩下的n-1个元素重新构建成大顶堆
4. 重复第二步和第三步直到整个数组排序完成。

如何构造一个大顶堆

建立一个大顶堆是从最后一个非叶子结点开始从下往上调整的，也就是从最后一个结点的父结点开始。

这里以int a[6] = {7, 3, 8, 5, 1, 2}为例子。数组的长度是6，则最后一个结点的下标是5.

先要找到最后一个结点的父结点：(5-1)/2=2。2所对应的数是8。然后比较该结点值和它的左右孩子结点的值，如果小于其左右孩子的值，就交换，把最大左右孩子最大的值放到该结点
8只有一个左子树，左子树的值为2，不需要跳转

下一步，继续找到下一个非叶子结点（其实就是当前坐标-1就行了），该结点的值是3，小于其左子树的值，交换值。


下一步，继续找下一个非叶子结点，该结点的值是7，小于右子树，需要交换


下一步，检查调整后的子树，是否满足大顶堆的性质，如果不满足则继续调整（这里因为只将右子树的值与根节点互换，只需要检查右子树是否满足，而7>2刚好满足大顶堆的性质，就不需要调整了）

到这里大顶堆的构造就完成了。

排序

大顶堆已经构造好了，下一步交换根结点和最后一个结点（将最大值放到数组末端），此时最大的元素就归位了，然后对剩下的5个元素重复上面的步骤：

剩下只有5个元素，把剩下的结点变为大顶堆

将根结点（7）与最后一个结点交换：

依次类推，最后得到排好序的数组：

/* Function: 构建大顶堆 */
void BuildMaxHeap(int *heap, int len)
{
    int i;
    int temp;

    for (i = len/2-1; i >= 0; i--)
    {
        if ((2*i+1) < len && heap[i] < heap[2*i+1])    /* 根节点小于左子树 */
        {
            temp = heap[i];
            heap[i] = heap[2*i+1];
            heap[2*i+1] = temp;
            /* 检查交换后的左子树是否满足大顶堆性质 如果不满足 则重新调整子树结构 */
            if ((2*(2*i+1)+1 < len && heap[2*i+1] < heap[2*(2*i+1)+1]) || (2*(2*i+1)+2 < len && heap[2*i+1] < heap[2*(2*i+1)+2]))
            {
                BuildMaxHeap(heap, len);
            }
        }
        if ((2*i+2) < len && heap[i] < heap[2*i+2])    /* 根节点小于右子树 */
        {
            temp = heap[i];
            heap[i] = heap[2*i+2];
            heap[2*i+2] = temp;
            /* 检查交换后的右子树是否满足大顶堆性质 如果不满足 则重新调整子树结构 */
            if ((2*(2*i+2)+1 < len && heap[2*i+2] < heap[2*(2*i+2)+1]) || (2*(2*i+2)+2 < len && heap[2*i+2] < heap[2*(2*i+2)+2]))
            {
                BuildMaxHeap(heap, len);
            }
        }
    }
}

/* Function: 交换交换根节点和数组末尾元素的值*/
void Swap(int *heap, int len)
{
    int temp;

    temp = heap[0];
    heap[0] = heap[len-1];
    heap[len-1] = temp;
}


int main()
{
    int a[6] = {7, 3, 8, 5, 1, 2};
    int len = 6;    /* 数组长度 */
    int i;

    for (i = len; i > 0; i--)
    {
        BuildMaxHeap(a, i);
        Swap(a, i);
    }
    for (i = 0; i < len; i++)
    {
        printf("%d ", a[i]);
    }

    return 0;
}

3 冒泡排序

https://www.runoob.com/w3cnote/bubble-sort.html