排序：正序冒泡，交错冒泡，插入排序，选择排序，快速排序

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
const int N=10;                            //修改随机数据量
bool onOroff=1;                            //数组打印开关：1要打印，0不打印
void bubble_sort(int a[],int n)
{
    for(int i=0 ; i<N ; ++i)
    {
        for(int j=0 ; j<N-1 ; ++j)
            if(a[j]>a[j+1])
            {
                int tmp=a[j+1];
                a[j+1]=a[j];
                a[j]=tmp;
            }
    }
}

void bubble_sort2(int a[],int n)
{
    int i=0,j=n-1;
    while(i<j)
    {
        for(int k=i ; k<=j-1 ; ++k)
            if(a[k]>a[k+1])
            {
                int tmp=a[k+1];
                a[k+1]=a[k];
                a[k]=tmp;
            }
        --j;
        if(i>=j)
            break;
        for(int k=j ; k>=i ; --k)
            if(a[k]<a[k-1])
            {
                int tmp=a[k-1];
                a[k-1]=a[k];
                a[k]=tmp;
            }
        ++i;
    }
}

void insert_sort(int a[],int n)
{
    int i=1,j=0,now=0,tmp=0;
    for(i=1 ; i<N ; ++i)
    {
        now=a[i];
        for(j=i-1 ; j>=0 ; --j)
        {
            if(a[j]>now)
                a[j+1]=a[j];
            else
                break;
        }
        a[j+1]=now;
    }
}

void select_sort(int a[],int n)
{
    int MIN,MINi,tmp;
    for(int i=0 ; i<N ; ++i)
    {
        MIN=0x3fffffff;
        for(int j=i ; j<N ; ++j)
            if(a[j]<MIN)
            {
                MINi=j;
                MIN=a[j];
            }
        tmp=a[i];
        a[i]=a[MINi];
        a[MINi]=tmp;
    }
}

int part_qsort(int a[], int n ,int l,int r)
{
    int mid=0,tmpmid=a[l];
    while(l<r)
    {
        while(l<r && a[r]>=tmpmid)
            --r;
        if(l<r)
        {
            a[l]=a[r];
            ++l;
        }
        else
            break;
        while(l<r && a[l]<=tmpmid)
            ++l;
        if(l<r)
        {
            a[r]=a[l];
            --r;
        }
        else
            break;
    }
    a[l]=tmpmid;
    return l;
}

void myquick_sort(int a[],int n,int l,int r)
{
    int position;
    if(l<r)
    {
        position=part_qsort(a,n,l,r);
        myquick_sort(a,n,l,position-1);
        myquick_sort(a,n,position+1,r);
    }
}

void P(int a[],int n)
{
    if(1==onOroff)
    {
        for(int i=0 ; i<N ; ++i)
            printf("%d ",a[i]);
        printf("
");
    }
}

int main(int argc,char* argv[])
{
    //排序
    clock_t bg,end;
    srand(time(NULL));
    int arr3[N];
    for(int i=0 ; i<N ; ++i)
        arr3[i]=rand()%100;
    printf("随机数据量：%d
原始数组：",N);
    P(arr3,N);
    printf("
");
    //正序冒泡
    int arr_bubble[N];
    memcpy(arr_bubble,arr3,sizeof(arr3));
    bg=clock();
    bubble_sort(arr_bubble,N);
    end=clock();
    printf("正序冒泡：");
    P(arr_bubble,N);
    printf("耗时：%5.15f秒

",(double)(end-bg)/CLOCKS_PER_SEC);
    //交错冒泡
    memcpy(arr_bubble,arr3,sizeof(arr3));
    bg=clock();
    bubble_sort2(arr_bubble,N);
    end=clock();
    printf("交错冒泡：");
    P(arr_bubble,N);
    printf("耗时：%5.15f秒

",(double)(end-bg)/CLOCKS_PER_SEC);
    //插入排序
    memcpy(arr_bubble,arr3,sizeof(arr3));
    bg=clock();
    insert_sort(arr_bubble,N);
    end=clock();
    printf("插入排序：");
    P(arr_bubble,N);
    printf("耗时：%5.15f秒

",(double)(end-bg)/CLOCKS_PER_SEC);
    //选择排序
    memcpy(arr_bubble,arr3,sizeof(arr3));
    bg=clock();
    insert_sort(arr_bubble,N);
    end=clock();
    printf("选择排序：");
    P(arr_bubble,N);
    printf("耗时：%5.15f秒

",(double)(end-bg)/CLOCKS_PER_SEC);
    //快速排序
    memcpy(arr_bubble,arr3,sizeof(arr3));
    bg=clock();
    myquick_sort(arr_bubble,N,0,N-1);
    end=clock();
    printf("快速排序：");
    P(arr_bubble,N);
    printf("耗时：%5.15f秒

",(double)(end-bg)/CLOCKS_PER_SEC);

    system("pause");
    return 0;
}