排序算法1

1）插入排序

说明：最坏情况运行时间为O(n*n)，原地排序（sorted in place）,稳定的

其内部循环紧密，对小规模输入来说是快速的

void insertion_sort(int a[], int length)
{
    int i, j, key;

    for(j = 1; j < length; j++) {
        key = a[j];
        i = j - 1;
        while(i > 0 && a[i] > key) {
            a[i + 1] = a[i];
            i--;
        } 
        a[i +1] = key;
    } 
}

2）冒泡排序

说明：时间复杂度为O(n*n)，稳定的

比较简单 

void bubble_sort(int a[], int length)
{
    int i, j, temp, exchange;

    for(i = 0; i < length; i++) {
        exchange = 0;
        for(j = n - 1; j >= i + 1; j --)
            if(r[j] < r[j - 1]) {
                temp = r[j];
                r[j] = r[j - 1];
                r[j - 1] = temp;
                exchange = 1;
            }
        if(exchange == 0)
            return;
    }
}

3)希尔排序

说明：时间复杂度为 O(N*(logN))，不稳定

中等大小规模表现良好，对规模非常大的数据排序不是 最优选择。希尔排序非常容易实现，算法代码短而简单。 此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多

void shell_sort(int a[], in length)
{
    int i, j, gap, temp;

    for(gap = length / 2; gap > 0; gap /= 2) {
        for(i = gap; i < length; i++) {
            for(j = i - gap; j >= 0 && v[j] > v[j + gap]; j -= gap) {
                temp = v[j];
                v[j] = v[i];
                v[i] = temp;    
            }
        }
    }
}

 

4）快速排序

说明：O(nlog n) 期望时间，O(n^2) 最坏情况； 不稳定的

对于大的、乱数列表一般相信是最快的已知排序

void quick_sort(int s[], int start, int end)
{
    int i, last;

    if(start >= end)
        return;

    swap(a, start, (start + end) / 2);
    last = start;
    for(i = last + 1; i <= end; i++) {
        if(v[i] < v[start])
            swap(a, ++last, i);
    }
    swap(a, start, last);
    quick_sort(a, start, last - 1);
    quick_sort(a, lsst + 1, end);
}

void swap(int a[], int i, int j)
{
    int temp;

    temp = v[j];
    v[j] = v[i];
    v[i] = temp;
}

 

5）选择排序

说明：时间复杂度为O(n*n)，不稳定 

void select_sort(int a[], int length)
{
    int i, j, k, temp;

    for(i = 0; i <= length - 2; i++) {
        k = i;
        for(j = i + 1; j <= length - 1; j++)
            if(a[j] < a[k])
                k = j;
        temp = a[i];
        a[i] = a[k];
        a[k] = temp;
    }
}

6）堆排序

说明：时间复杂度为O(n*logN)，原地排序，不稳定

void heap_sort(int a[], int length)
{
    int i, temp;

    for(i = length / 2; i >= 1; i--)
        shift(a, i, length);

    for(i = length; i >= 2; i--) {
        temp = a[i];
        a[i] = a[1];
        a[1] = temp;
        shift(a, 1, i - 1);
    }
}

void shift(int a[], int l, int m)
{
    int i, j, temp;

    i = l;
    j = 2 * i;
    temp = a[i];

    while(j < m) {
        if(j < m && a[j] < a[j + 1])
            j++;
        if(temp < r[j]) {
            a[i] = a[j];
            i = j;
            j = 2 * i;

        }
        else
            j = m + 1;
    }
    a[i] = temp;
}

7）归并排序

说明：时间复杂度为O(nlog n)， 需要 O(n) 额外空间，稳定的

void merge(int a[], int l, int m, int h, int b[])
{
    int i, j, k;

    k = 1;
    i = l;
    j = m + 1;
  
    while(i <= m && j <= h) {
        if(a[i] <= a[j])
            b[k] = a[i++];
        else
            b[k] = a[j++];
        k++;
    }

    while(j <= h) b[k++] = a[j++];
    while(i <= m) b[k++] = a[i++];
}