常见几种排序总结

//************************************
//本程序演示内容如下：
//1.常见几种数据排序总结

//2.main参数使用

//3.数组指针函数使用

//zping 2012-3-13

//************************************
#include<stdio.h>


//冒泡法:
//第一轮:从倒数第1，2两个比较，把较小的提到前面然后从倒
//       数第2，3两个比较，把较小的提到前面，以此类推，
//       最后一定是把这组数据中最小的提到了最前面。
//第二轮:从这组数据正数第二个元素开始重复第一轮步骤，后
//       面几轮以此类推
void BubbleSort(int *buf,int count)
{
    int i,j,temp;
    for(i=1;i<count;i++)
        for(j=count-1;j>=i;j--)
        {
            if(buf[j-1]>buf[j])
                {
                    temp=buf[j];
                    buf[j]=buf[j-1];
                    buf[j-1]=temp;
                }
        }
    printf("BubbleSort:\n");
}


//交换法
//第一轮:将第一个元素依次和后面所有的元素比较，如果该
//       元素比后面某个元素大则交换。然后继续比较。结
//       束后，第一个元素一定是最小的。
//第二轮:从这组数据正数第二个元素开始重复第一轮步骤，后
//       面几轮以此类推
void ExchangeSort(int *buf,int count)
{
    int i,j,temp;
    for(i=0;i<count-1;i++)
        for(j=i+1;j<count;j++)
        {
            if(buf[j-1]>buf[j])
                {
                    temp=buf[j];
                    buf[j]=buf[j-1];
                    buf[j-1]=temp;
                }
        }
    printf("ExchangeSort:\n");
}


//选择法
//第一轮:将第一个元素依次和后面所有的元素比较，如果该
//       元素比后面某个元素大先记录序号不交换。然后继
//       续比较。结束后记录的序号一定是除第一个元素外
//       是最小的元素，然后再和第一个元素交换。这样相
//       对交换法排序就有可能减少了交换次数。
//第二轮:从这组数据正数第二个元素开始重复第一轮步骤，后
//       面几轮以此类推
void SelectSort(int *buf,int count)
{
    int i,j,min,temp;
    for(i=0;i<count-1;i++)
    {
        min=i;
        for(j=i+1;j<count;j++)
        {
            if(buf[min]>buf[j])
                min=j;
        }
        if(min!=i)
        {
            temp=buf[i];
            buf[i]=buf[min];
            buf[min]=temp;
        }
    }
    printf("SelectSort:\n");
}


//插入法:
//思想： 我们假设前面(n-1)[n>=2]个数已尽是排好顺序的，现
//       在要把第n个元素插到前面的有序数中，使得这n个数也
//       是有序的，然后再依次类推直到全部排好序。例如:
//[初始关键字] [49] 38 65 97 76 13 27 49
//    J=2(38) [38 49] 65 97 76 13 27 49
//    J=3(65) [38 49 65] 97 76 13 27 49
//    J=4(97) [38 49 65 97] 76 13 27 49
//    J=5(76) [38 49 65 76 97] 13 27 49
//    J=6(13) [13 38 49 65 76 97] 27 49
//    J=7(27) [13 27 38 49 65 76 97] 49
//    J=8(49) [13 27 38 49 49 65 76 97]
void InsertSort(int *buf,int count)
{
    int i,j,temp;
    for(i=1;i<count;i++)
    {
        temp=buf[i];
        //用temp和有序数比较，如果小则把有序数往后挪，腾出一个位置给temp。
        for(j=i-1;j>=0 && temp<buf[j];j--) 
        {
            buf[j+1]=buf[j];
        }
        buf[j+1]=temp;//因为前面j多减了一次，所以此处是j+1
    }
    printf("InsertSort:\n");
}
//快速法:
//思想：1.找一个基准点，然后把比基准点大得放右边，小的放左边
//      2.然后在左右两边分别重复步骤1 显然可以使用递归
void run_recur(int *data,int left,int right)
{
    int i,j,middle,temp;
    i=left;
    j=right;
    middle=data[(left+right)/2];
    do
    {
        while((data[i]<middle) && (i<right))
            i++;
        while((data[j]>middle) && (j>left))
            j--;
        if(i<=j)
        {
            temp=data[i];
            data[i]=data[j];
            data[j]=temp;
            i++;
            j--;
        }
    }while(i<=j);
    
    if(left<j)
       run_recur(data,left,j);
    if(right>i)
       run_recur(data,i,right);
}
void QuickSort(int *buf,int count)
{
    run_recur(buf,0,count-1);
    printf("QuickSort:\n");
}


//希尔法：
//在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，
//并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为
//增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除
//多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现
//了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中
//记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量
//对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成
//一组，排序完成。
//下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，
//以后每次减半，直到增量为1。
//希尔排序是不稳定的。
void ShellSort(int *buf, int count)
{
    int h, j, k, t;


    for (h=count/2; h>0; h=h/2) /*控制增量*/
    {
        for (j=h; j<count; j++) /*这个实际上就是上面的直接插入排序*/
        {
            t = buf[j];
            for (k=j-h; (k>=0 && t<buf[k]); k-=h)
            {
                buf[k+h] = buf[k];
            }
            buf[k+h] = t;
        }
    }
    printf("ShellSort:\n");
}


int main(int argc,char **argv)
{
    int a[8]={49,38,65,97,76,13,27,49};//准备从小到大排序
    int i,len=8;
    void (*fun[])()={BubbleSort,ExchangeSort,SelectSort,InsertSort,QuickSort,ShellSort};
    
    if(argc<=1 || argc>2) 
    {
        printf("please enter parameter: 1|2|3|4|5|6\n");
        exit(1);
    }
    if(*argv[1]<'1' || *argv[1]>'6') 
    {
        printf("parameter error!\nparameter: 1|2|3|4|5|6\n");
        exit(1);
    }
    printf("original data:\n");
    for(i=0;i<len;i++)
        printf("%d ",a[i]);
    printf("\n");
    fun[*argv[1]-0x31](a,len);
    for(i=0;i<len;i++)
        printf("%d ",a[i]);
    printf("\n");
    return 0;
}