排序算法及实现

排序算法可以总结为如下：

都将数组分为已排序部分和未排序部分。

冒泡排序将已排序部分定义在右端，在遍历未排序部分的过程执行交换，将最大元素交换到最右端。

插入排序将已排序部分定义在左端，将未排序部分元的第一个元素插入到已排序部分合适的位置。

选择排序将已排序部分定义在左端，然后选择未排序部分的最小元素和未排序部分的第一个元素交换。

几种排序算法，可以执行运行

这是测试结果：  希尔排序最快

C 语言
shelltime 0.034712
selecttime 11.054244
bubbletime 27.751209
inserttime 15.421586
sorttime 8.588640

代码实现：
#include <stdio.h>
#include <stdlib.h>
#include <time.h>


int a[100000];
int b[100000];
int c[100000];
int d[100000];
int e[100000];

int n=100000 ;

// 产生随机数
int outrand(void)  // 产生随机数
{
    int i;
    srand(time(0));
    for(i=0; i < n; i++)
    {
        a[i] = rand()%100;
        b[i] = a[i];
        c[i] = a[i];
        d[i] = a[i];
        e[i] = a[i];
    }
}

// 打印输出
void output(int a[], int n)
{
    int i;
    for(i = 0; i < n; i++)
        printf("%d, ", a[i]);
    printf("\n");
}

// 二分法插入排序
void sort(int a[], int n)   // 二分法插入排序
{
    int i,  temp, m, d, k;
    int high,low;

    for(i = 1; i < n; i++)  // 从未排序序列 选择一个
    {
        high = i -1;
        low = 0;
        m =  high/2;
        while(high >= low) // 用二分法 查询 
        {
            m = (high + low)/2;
            if(a[m] == a[i])
                break;
            if(a[m] > a[i])
            {
                high = m -1;
                d = 0;
            }else if(a[m] < a[i])
            {
                low = m + 1;
                d = 1;
            }
        }
        for(k = i; m < i-d; m++, k--) // 把i值 插入
        {
            temp = a[k];
            a[k] = a[k-1];
            a[k-1] = temp;
        }
    }
}

// 插入排序
void insertsort(int a[], int n)
{
    int i, j, temp;

    for (i = 1; i < n ; i++)  // 从未排序序列中 选择一个，假定 0 已经是已排序列
        for(j = i; j > 0; j--)  // 对已排序 序列操作
        if(a[j-1] > a[j])   // 相当于冒泡
        {
            temp = a[j];
            a[j] = a[j-1];
            a[j-1] = temp;
        }
}

// 希尔排序， 其实就是分组后，在每组中用插入排序，然后再分组，再插入排序
void shellsort(int a[], int n)
{
    int i, j, gap;

    for(gap = n / 2; gap > 0; gap /= 2) // 分组 步长
        for(i = 0; i < gap; i++)        // 每组都要用插入排序
        {
            for(j = i + gap; j < n; j += gap)
                if (a[j] < a[j-gap])
                {
                    int temp = a[j];
                    int k = j-gap;
                    while (k >= 0 && a[k] > temp)
                    {
                        a[k + gap] = a[k];
                        k -=gap;
                    }
                    a[k + gap] = temp;
                }
        }
}

// 选择排序
void selectsort(int a[], int n)
{
    int i, j, max, temp;

    for(i = 0; i < n-1 ; i++) // 第一层循环是，把找到的最大值，排到已排序的序列中
    {
        max = i;
        for(j = i; j < n; j++) // 第二层循环是 从未排序序列中找最大值
            if( a[max] < a[j+1])
                max =j+1;

        temp = a[max];     
        a[max] = a[i];
        a[i] = temp;
    }
}

// 冒泡排序
void bubblesort(int a[], int n)
{  
    int i, j, temp;  
  
    for(i = 0; i < n ; i++)   // 第一层循环是
        for(j = 0; j < n-i-1; j++) // 两两比对，
            if(a[j] > a[j+1])
            {
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
}  

// 主函数
void main(void)
{
    clock_t start,end;
    outrand();
    start = clock();
    shellsort(a,n);
    end = clock();
    printf("shelltime %f \n",(double)(end-start)/1000000);

    start = clock();
    selectsort(b,n);
    end = clock();
    printf("selecttime %f \n",(double)(end-start)/1000000);

    start = clock();
    bubblesort(c,n);
    end = clock();
    printf("bubbletime %f \n",(double)(end-start)/1000000);
  
    start = clock();
    insertsort(d,n);
    end = clock();
    printf("inserttime %f \n",(double)(end-start)/1000000);

    start = clock();  
    sort(e,n);
    end = clock();
    printf("sorttime %f \n",(double)(end-start)/1000000);
}