八个排序算法

发现一个神器：http://visualgo.net/

1.插入排序(Insert Sort)

基本思想：
将一个记录插入到已经有序的记录序列中，得到一个新的、记录数加1的序列。排序时，将第一个记录先视为有序，再依次对后面的记录进行插入。

可以想象自己是在打牌，首先摸到一张牌，认为他是有序的，然后每摸到一张牌就要跟手里的牌作比较，找到正确的插入位置。

时间复杂度：

O(n^2)，当序列为逆序时。

伪代码：

void insertSort(int a[]){
    int len;  //数组的长度
    for(len=0; a[len]; len++) ;
    int key; //带排关键字
    for(int j=1; j<len; j++){
        key = a[j];
        int i=j-1;
        while(i>0 && key<a[i]){
            a[i+1] = a[i];
            i--;
        }
        a[i+1] = key;
    }
}

2.归并排序（Merge Sort)

基本思想：
运用分治法的思想。将一个序列分为左右两个子序列，将两个子序列分别排序后，进行合并。整个归并排序可以分成两个过程：1）左右子序列各自排序，2）左右子序列合并。

合并的过程依然想象自己是在打牌。左右两堆牌按序正面朝上放到桌上（比如从上到下是从小到大的顺序），每次接起两堆最上面较小的一张牌，这样就可以把两堆有序的牌合并成一堆有序的牌了。当然实现的时候要注意给每堆牌的底部加一个哨兵，当看见哨兵的时候就把另一堆剩下的牌直接复制过来就好了。

左右子序列各自排序的过程其实是递归调用的，递归到左右两堆只剩一张牌的时候，认为各自有序，就开始合并。有点树的意思，子节点一层层向上构成父节点，最后的根节点就是整个排好序的数组

时间复杂度：

O(nlgn)

伪代码：

#define INF 65535
void merge(int a[], int p, int q, int r){
    int n1 = q-p+1;  //已排好序的两个子序列的长度
    int n2 = r-q;
    vector<int> L,R;  //复制两个子序列的值
    for(int i=1; i<=n1; i++){  //L,R里从上到下存放的值从小到大
        L.push_back(a[p+i-1]);
    }
    for(int j=1; j<=n2; j++){
        R.push_back(a[q+j]);
    }
    L.push_back(INF);
    R.push_back(INF);
    i=0;
    j=0;
    for(int k=p; k<=r; k++){
        if(L[i] <= R[j]){
            if(R[j] == INF){   //如果某一边遇到了无穷大，则把另一边后面的值直接复制就好
                while(L[i]!=INF && k<=r){
                    a[k] = L[i];
                    i++; 
                    k++;
                }
            }
            else{
                a[k] = L[i];
                i++;
            }
        }
        else if(L[i] > R[j]){
            if(L[i] == INF){
                while(R[j]!=INF && k<=r){
                    a[k] = R[j];
                    j++; 
                    k++;
                }
            }
            else{
                a[k] = R[j];
                j++;
            }
        }
    }
}

void mergeSort(int a[], int p, int r){
    if(p < r){
        int q = (p+r)/2;
        mergeSort(a,p,q);
        mergeSort(a,q+1,r);
        merge(a,p,q,r);
    }
}

3.堆排序(Heap Sort)

基本思想：
待续。。。

时间复杂度：

O(nlgn)

像合并排序一样，它的时间复杂度是O(nlgn)，想插入排序一样，它是一种原地排序的算法，数组中只有常数个元素存储在输入数组之外。因此，堆排序结合了合并排序和插入排序的优点。这是一种

2.插入排序——希尔排序(Shell Sort)

基本思想：
把一个序列分成gap组，在组内用直接插入排序。gap初值为n/2，之后依次变成gap=gap/2，直到gap=1.。
时间复杂度：
最优：复杂度为O(n)，当序列已经有序时；
最差：复杂度为O(n^2)，当序列为逆序时。

void Sort::ShellSort(vector<int> &s){
<pre name="code" class="cpp">    int size = s.size();
    int gap ;  //每次的gap值
    int i, j, k, key;
    for(gap = size/2; gap>0; gap /= 2){  
        for(i=0; i<gap; i++){   //每次分成gap组
            for(j=i+gap; j<size; j+=gap){//每组中有n/gap个值
                if(s[j] < s[j-gap]){   //对着n/gap个值进行直接插入排序
                    key = s[j];
                    k = j-gap;
                    while( k>=0 && s[k]>key){
                        s[k+gap] = s[k];
                        k -= gap;
                    }
                    s[k+gap] = key;
                }
            }
        }
    }
}

 

3.选择排序——简单选择排序(Simple Selection Sort)

基本思想：
对于序列中的每一个值，从后续序列中找到一个最小的跟它交换。
时间复杂度：
最优：复杂度为O(n)，当序列已经有序时；
最差：复杂度为O(n^2)，当序列为逆序时。

void Sort::SimpleSelectionSort(vector<int> &s){
    int sz = s.size(); 
    int i, j, k, smallest, temp;
    for(i=0; i<sz-1; i++){
        smallest = s[i];
        k = i;
        for(j=i+1; j<sz; j++){ //寻找一堆数里的最小值
            if(s[j] < smallest){
                smallest = s[j];
                k = j;  //记住最小值的下标
            }
        }
        temp = s[i];
        s[i] = s[k];
        s[k] = temp;
    }
}

4.选择排序——堆排序(Heap Sort)

基本思想：
待续。。。

时间复杂度：

O(nlgn)

像合并排序一样，它的时间复杂度是O(nlgn)，想插入排序一样，它是一种原地排序的算法，数组中只有常数个元素存储在输入数组之外。因此，堆排序结合了合并排序和插入排序的优点。这是一种

5.交换排序——冒泡排序(Bubble Sort)

基本思想：
对序列中的每一个元素，如果与后面相邻元素反序，则重复的交换。如果是升序排列，每循环一次都会把当前最大的一个沉底。
时间复杂度：

O(n^2)

伪代码：

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

6.交换排序——快速排序（Quick Sort)

void Sort::QuickSort(int s[], int low, int high){   // low, high分别记录要排序序列的起始位置
//    int low = 0, high = sz-1;
    if( low >= high)
        return;
    int first = low, last = high;   //first, last记录分段子序列的起始位置
    int key = s[first];  
    while(first < last && first < last){
        while( s[last] > key )
            last--;
        swap( s[first], s[last]);
        while( first < last && s[first] < key )
            first++;
        swap( s[first], s[last] );
    }
    QuickSort(s, low, first-1);   //分段排序
    QuickSort(s, first+1, high);
    return ;
}

对排序算法的改进：

1.在插入排序寻找键值key的过程中使用二分查找法。它用的也是分治的思想，如果整个的用时为T(n)，分成一半的用时为T(n/2)，每次分完它只比较了一次（待寻找的值和a[mid]），所以T(n) = c（当v=a[(n-1)/2]时）或者T(n/2)+c（一般情况下），求解这个式子，得T(n)=lgn.

int bSearch(int a[], int v){
    int len;
    for(len=0; a[len]; len++) ;
    int left = 0;
    int right = len-1;
    int mid;
    while(!(left > right)){
        mid = (left+right)/2;
        if(v < a[mid])
            right = mid-1;
        else if(v > a[mid])
            left = mid+1;
        else 
            return mid;
    }
    return mid;
}

将二分查找用在插入排序中

（未完待续。。。）