Android音视频学习 之C语言入门之三大经典排序(六)

C排序算法

冒泡排序

冒泡排序（Bubble Sort） 最为简单的一种排序，通过重复走完数组的所有元素，通过打擂台的方式两个两个比较，直到没有数可以交换的时候结束这个数，再到下个数，直到整个数组排好顺序。因一个个浮出所以叫冒泡排序。双重循环时间 O(n^2)

过程演示：

基本思想

1. 比较相邻两个数据如果。第一个比第二个大，就交换两个数
2. 对每一个相邻的数做同样1的工作，这样从开始一队到结尾一队在最后的数就是最大的数。
3. 针对所有元素上面的操作，除了最后一个。
4. 重复1~3步骤，知道顺序完成。

示例

代码如下：

#include <stdio.h>

void bubble_sort (int aar[],int len);
int  main(int var , char  *ptr[]){
    int arr[] = { 3, 6, 4, 2, 11, 10, 5  };
    int lens = (int)sizeof(arr)/sizeof(*arr);
    bubble_sort(arr,lens);
    for (int i = 0; i <lens ; ++i) {
        printf("%d ",arr[i]);
    }

    return  0;
}


void bubble_sort(int aar[],int len){
    int  i,j,temp;


    for (int i = 0; i <len-1 ; ++i) {

        for (int j = 0; j <len-1-i ; ++j) {
            if (aar[j]>aar[j+1]){
                temp =aar[j];
                aar[j]=aar[j+1];
                aar[j+1]=temp;

            }
        }

    }

}

输出结果：

2 3 4 5 6 10 11

选择排序

选择排序（Select Sort） 是直观的排序，首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。双重循环时间复杂度为 O(n^2)

算法描述：

1. 在一个长度为 N 的无序数组中，第一次遍历 n-1 个数找到最小的和第一个数交换。
2. 第二次从下一个数开始遍历 n-2 个数，找到最小的数和第二个数交换。
3. 重复以上操作直到第 n-1 次遍历最小的数和第 n-1 个数交换，排序完成。

#include <stdio.h>

void selection_sort (int aar[],int len);
int  main(int var , char  *ptr[]){
    int arr[] = { 3, 6, 4, 2, 11, 10, 5  };
    int lens = (int)sizeof(arr)/sizeof(*arr);
    selection_sort(arr,lens);
    for (int i = 0; i <lens ; ++i) {
        printf("%d ",arr[i]);
    }

    return  0;
}


void selection_sort(int aar[],int len){
    int aarMin,temp;

    for (int i = 0; i < len; ++i) {
        aarMin =aar[i];
        for (int j = i+1; j < len; ++j) {//走訪未排序的元素
            if (aarMin>aar[j]){  //遍历查找到目前最小值；
                temp =aarMin;
                aarMin= aar[j];
                aar[j]=temp;    //将最小值进行交换；
            }
            aar[i]=aarMin;  //然后放到已排序序列的末尾
        }


    }

}

输出结果：

2 3 4 5 6 10 11

快速排序

快速排序（QuickSort）是排除稳定性因素后最常用的排序。给看官介绍两种使用方法，一种值直接在我文件 stdlib.h 头文件中的 qsort 函数实现是和正常写代码一样的。通过使用qsort（数组名，长度，sizeof（第一个数长度），compInc/comoDec) 进行实现数组的排序。后面的是通过递归调用的形式。

过程演示：

算法描述：

1. 在一个长度为 N 的无序数组中，第一次遍历 n-1 个数找到最小的和第一个数交换。
2. 第二次从下一个数开始遍历 n-2 个数，找到最小的数和第二个数交换。
3. 重复以上操作直到第 n-1 次遍历最小的数和第 n-1 个数交换，排序完成。

理解起来还是比较难懂下面举个例子：

假设我们现在对“6 1 2 7 9 3 4 5 10 8”这个 10 个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数 6 作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在 6 的右边，比基准数小的数放在 6 的左边，类似下面这种排列。

3 1 2 5 4 6 9 7 10 8

在初始状态下，数字 6 在序列的第 1 位。我们的目标是将 6 挪到序列中间的某个位置，假设这个位置是 k。现在就需要寻找这个 k，并且以第 k 位为分界点，左边的数都小于等于 6，右边的数都大于等于 6。想一想，你有办法可以做到这点吗？

方法其实很简单：分别从初始序列“6 1 2 7 9 3 4 5 10 8”两端开始“探测”。先从右往左找一个小于 6 的数，再从左往右找一个大于 6 的数，然后交换他们。这里可以用两个变量 i 和 j，分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵 i”和“哨兵 j”。刚开始的时候让哨兵 i 指向序列的最左边（即 i=1），指向数字 6。让哨兵 j 指向序列的最右边（即 j=10），指向数字 8

首先哨兵 j 开始出动。因为此处设置的基准数是最左边的数，所以需要让哨兵 j 先出动，这一点非常重要（请自己想一想为什么）。哨兵 j 一步一步地向左挪动（即 j–），直到找到一个小于 6 的数停下来。接下来哨兵 i 再一步一步向右挪动（即 i++），直到找到一个数大于 6 的数停下来。最后哨兵 j 停在了数字 5 面前，哨兵 i 停在了数字 7 面前。

现在交换哨兵 i 和哨兵 j 所指向的元素的值。交换之后的序列如下。

6 1 2 5 9 3 4 7 10 8

到此，第一次交换结束。接下来开始哨兵 j 继续向左挪动（再友情提醒，每次必须是哨兵 j 先出发）。他发现了 4（比基准数 6 要小，满足要求）之后停了下来。哨兵 i 也继续向右挪动的，他发现了 9（比基准数 6 要大，满足要求）之后停了下来。此时再次进行交换，交换之后的序列如下。

6 1 2 5 **4 **3 9 7 10 8

第二次交换结束，“探测”继续。哨兵 j 继续向左挪动，他发现了 3（比基准数 6 要小，满足要求）之后又停了下来。哨兵 i 继续向右移动，糟啦！此时哨兵 i 和哨兵 j 相遇了，哨兵 i 和哨兵 j 都走到 3 面前。说明此时“探测”结束。我们将基准数 6 和 3 进行交换。交换之后的序列如下。

到此第一轮“探测”真正结束。此时以基准数 6 为分界点，6 左边的数都小于等于 6，6 右边的数都大于等于 6。回顾一下刚才的过程，其实哨兵 j 的使命就是要找小于基准数的数，而哨兵 i 的使命就是要找大于基准数的数，直到 i 和 j 碰头为止。

OK，解释完毕。现在基准数 6 已经归位，它正好处在序列的第 6 位。此时我们已经将原来的序列，以 6 为分界点拆分成了两个序列，左边的序列是“3 1 2 5 4”，右边的序列是“ 9 7 10 8 ”。接下来还需要分别处理这两个序列。因为 6 左边和右边的序列目前都还是很混乱的。不过不要紧，我们已经掌握了方法，接下来只要模拟刚才的方法分别处理 6 左边和右边的序列即可。现在先来处理 6 左边的序列现吧。

左边的序列是“3 1 2 5 4”。请将这个序列以 3 为基准数进行调整，使得 3 左边的数都小于等于 3，3 右边的数都大于等于 3。好了开始动笔吧。

如果你模拟的没有错，调整完毕之后的序列的顺序应该是。

2 1 3 5 4

OK，现在 3 已经归位。接下来需要处理 3 左边的序列“ 2 1 ”和右边的序列“5 4”。对序列“ 2 1 ”以 2 为基准数进行调整，处理完毕之后的序列为“1 2”，到此 2 已经归位。序列“1”只有一个数，也不需要进行任何处理。至此我们对序列“ 2 1 ”已全部处理完毕，得到序列是“1 2”。序列“5 4”的处理也仿照此方法，最后得到的序列如下。

1 2 3 4 5 6 9 7 10 8

对于序列“9 7 10 8”也模拟刚才的过程，直到不可拆分出新的子序列为止。最终将会得到这样的序列，如下。

1 2 3 4 5 6 7 8 9 10

到此，排序完全结束。细心的同学可能已经发现，快速排序的每一轮处理其实就是将这一轮的基准数归位，直到所有的数都归位为止，排序就结束了。下面上个霸气的图来描述下整个算法的处理过程。

代码示例如下：

#include <stdio.h>
void quicksort(int a[],int left,int right)
{

    int i,j,t,temp;
    if(left>right)
        return;
    //temp 中存储着基数；
    temp = a[left];
    //最左边的索引
    i=left;
    //最右边的索引；
    j=right;
    while(i!=j)
    {
        //顺序很重要。先从右边开始找；找到时候跳出循环；
        while(a[j]>=temp && i<j){
           j--;
        }
      while (a[i]<=temp &&i<j){
          i++;
      }
        //交换找到的两个数；
        if(i<j)
        {
            t=a[i];
            a[i]=a[j];
            a[j]=t;
        }
    }
    //当查找的左右索引像碰面（相等时）基数和碰面的索引数据进行交换；

    a[left]=a[i];
    a[i]=temp;
    quicksort(a,left,i-1);//继续处理左边的，这里是一个递归的过程
    quicksort(a,i+1,right);//继续处理右边的 ，这里是一个递归的过程
}
int main()
{
    int a[] = { 6, 5, 2, 7, 3, 9, 8, 4, 10, 1,0,14 };

    int lens =(int)sizeof(a)/sizeof(*a);
   //传入数组，数组的起始下标，数组长度
    quicksort(a,0,lens);

    for (int i = 0; i <lens ; ++i) {
        printf("%d ",a[i]);
    }

    return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9 10 14