冒泡，插入，折半插入，希爾，快速，簡單選擇排序源碼總結

#include <iostream>
using namespace std;
//各種排序方法：
/**冒泡排序法**/
//它的時間複雜度爲O（n^2），雖然不及堆排序、快速排序的O（nlogn，底數爲2），但是有兩個優點：1.“編程複雜度”很低，很容易寫出代碼；2.具有穩定性，這裏的穩定性是指原序列中相同元素的相對順序仍然保持到排序後的序列，而堆排序、快速排序均不具有穩定性。
void Bubble_sort(int s[],int len){
    int i,j,flag;
    for (i=len-1; i>=1; i--) {
        flag=1;
        for (j=i-1; j>=0; j--) {
            if (s[i]<s[j]) {
                swap(s[i], s[j]);
                flag=0;
            }
        }
        if (1==flag) {//表示已經排序完成
            break;
        }
    }
}
/**插入排序法**/
//插入排序的基本操作就是將一個數據插入到已經排好序的有序數據中，從而得到一個新的、個數加一的有序數據，算法適用於少量數據的排序，時間複雜度爲O(n^2)。是穩定的排序方法。
void Insert_sort(int s[],int len){
    int i,j;
    int temp;
    for(i=1;i<len;i++){
        temp=s[i];
        for (j=i; j>0&&temp<s[j-1]; j--) {
            s[j]=s[j-1];
        }
        s[j]=temp;
    }
}
/**折半插入排序法**/
//當第i個元素要進行排序的時候，它前面的1到i-1位置上的數據是局部有序的，對於有序的數據序列，採用折半查找法去判斷在何處插入i位置上的數據，就大大減少了需要比較的次數。
void HalfInsert_sort(int s[], int len){
    int temp, low, high, i, j, mid;
    for (i=1; i<len; ++i)
    {
        temp = s[i];
        low = 0;
        high = i - 1;

        while (high >= low)
        {
            mid = (low + high) / 2;

            if (temp < s[mid])
            {
                high = mid - 1;
            }

            else
            {
                low = mid + 1;
            }
        }

        for (j=i-1; j>=low; --j)
        {
            s[j+1] = s[j];
        }

        s[low] = temp;
    }
}

/**希爾排序法**/
//希爾排序法(縮小增量法) 屬於插入類排序，是將整個無序列分割成若干小的子序列分別進行插入排序的方法。
void Hill_sort(int s[],int len){
    int h,j,k,t;
    for (h=len/2; h>0; h=h/2) {//控制增量
        for (j=h;j<len; j++) {
            t=s[j];
            for (k=j-h; k>=0&&t<s[k]; k-=h) {
                s[k+h]=s[k];
            }
            s[k+h]=t;
        }
    }
}

/**快速排序法**/
//快速排序（Quicksort）是對冒泡排序的一種改進。通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
//挖坑法
void quick_sort1(int s[],int l, int r){
    int i=l;
    int j=r;
    int x=s[i];//第一個坑
    if(i>=j) return ;
    while (i!=j) {
        //從右向左找小於x的數來填s[i];
        while (i<j&&s[j]>=x) {
            j--;
        }
        s[i]=s[j];
        //從左向右找大於或等於x的數來填s[j];
        while (i<j&&s[i]<x) {
            i++;
        }
        s[j]=s[i];
    }
    s[i]=x;
    quick_sort1(s, l, i-1);
    quick_sort1(s, i+1, j);
}
/**簡單選擇排序法**/
//選擇排序(Selection sort)是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小元素，然後放到排序序列末尾(目前已被排序的序列)。以此類推，直到所有元素均排序完畢。
void Select_sort(int s[], int len){
    int i,j,min;
    for (i=0; i<len-1; i++) {
        min=i;
        for (j=i+1; j<len; j++)
            if (s[min]>s[j])
                min=j;
//把值最小的下標記下來
        if (min!=i)
            swap(s[i], s[min]);
    }
}