4种简单排序C编写

选择排序：

原理：从第一次待排序的数据种选出最小（最大）的一个元素，存放在序列的起始位置。

排序算法	平均时间	最好时间	最差时间	空间复杂度	稳定性
插入排序	O(n2)	O(n2)	O(n2)	O(1)	不稳定

程序实现：
void select_sort(int a[], int n)
{
    int mark;
    for(int i = 0; i < n - 1; ++i){
        for(int j = i + 1; j < n; ++j) {
            if(a[i] > a[j])
                swap(a[i], a[j]);
        }
    }
 } 

插入排序：

原理：构建有序序列，对于未排序数据，在已排序序列从后向前扫描，找到相应位置并插入。构建有序序列，对于未排序数据，在已排序序列从后向前扫描，找到相应位置并插入。

排序算法	平均时间	最好时间	最差时间	空间复杂度	稳定性
插入排序	O(n2)	O(n)	O(n2)	O(1)	稳定

算法步骤：

1. 将待排序序列第一个元素看成一个有序序列，第二个到最后一个看成无序序列。
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描。
3. 若该元素（已排序）大于新元素，则将该元素移到下一位置。
4. 重复步骤3，知道找到已排序的元素小于或等于新元素的位置。
5. 将新元素插入该位置，
6. 重复步骤2-5.

程序实现：

void insert_sort(int a[], int n)

{

        int  i = 0, j = 0, temp = 0;

        for (i = 1; i < n; ++i) {

                temp = a[i];

                for (j = i - 1; j >= 0; --j) {

                if (temp < a[j])

                        a[j + 1] = a[j];

                else break;

                }

                a[j + 1] = temp;

        }

}

冒泡排序：

原理：每次只比较当前元素和后一个元素的大小，若当前元素大于后一个元素，则交换，如此循环直到队尾。每轮排序都可以保证将当前排序下最大的元素送到未排序部分的队尾。

排序算法	平均时间	最好时间	最差时间	空间复杂度	稳定性
冒泡排序	O(n2)	O(n)	O(n2)	O(1)	稳定

程序实现：

void bubble_sort(int a[], int n)

{

        //一定进行N-1轮比较

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

                //每一轮比较前n-1-i个，即已排序好的最后i个不用比较

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

                        if (a[j] > a[j + 1]) {

                                int temp = a[j];

                                a[j] = a[j + 1];

                                a[j + 1] = temp;

                        }

                }

        }

}

优化

void bubble_sort_better(int a[], int n)

{

                //最多进行N-1轮比较

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

                bool isSorted = 1;

                //每一轮比较前n-1-i个，即已排序好的最后i个不用比较

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

                        if (a[j] > a[j + 1]) {

                                isSorted = 0;

                                int temp = a[j];

                                a[j] = a[j + 1];

                                a[j + 1] = temp;

                          }

                }

                if (isSorted)break;

        }        

}

快速排序（改进冒泡排序）

原理：将要排序的数分为2个部分，其中一部分的数据都比另一部分的数据小，然后递归进行上述操作，只要所有数据有序位置。

排序算法	平均时间	最好时间	最差时间	空间复杂度	稳定性
快速排序	O(nlgn)	O(nlgn)	O(n2)	O(lgn)	稳定

程序实现

void Quick_Sort(int a[], int left, int right)

{

        int pivot, i, j;

        if (left < right) {

                i = left - 1; //由于使用do...while..

                j = right + 1;

                pivot = a[left];//选定某一值。

                do {

                        do ++i; while (a[i] < pivot);

                        do --j; while (a[j] > pivot);

                        if (i < j)swap(a[i], a[j]);

                } while (i < j);

        }

        else return;

        swap(a[left], a[j]);

        Quick_Sort(a, left, j);

        Quick_Sort(a, j + 1, right);

}