常用排序算法总结

#include <stdio.h>
#include <stdlib.h>
#define ARRAYNUM 5
int power(int x,int y);
void swap(int *a,int *b);
int returnbitnum(int temp,int bit,int maxbit);
void bubbleSort(int a[]);
void selectSort(int a[]);
void quickSort(int a[],int startpoint ,int endpoint);
void insertSort(int a[]);
void shellSort(int a[]);
void baseSort(int a[]);

main()
{
    int a[ARRAYNUM]={1,271,0,12,12};
    //printf("give the value to the array:/n");
    int i=0;
    //for(i=0;i<ARRAYNUM;i++){
    //  scanf("%d",&a[i]); 
    //}
    //printf("give the value to the array end/n");
//  bubbleSort(a);
//  selectSort(a);
//  quickSort(a,0,ARRAYNUM-1);
//  insertSort(a);
//  shellSort(a);
    baseSort(a);
//  printf("Output the value of array after sort/n");
    for(i=0;i<ARRAYNUM;i++){
    printf(" a[%d]=%d/n",i,a[i]);  
    }
    printf("***************************************/n");
}




/******************************************************************************************
 *数据交换
********************************************************************************************/

void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}

/******************************************************************************************
 *冒泡排序
 *依次比较相邻的两个数，将小数放在前面，大数放在后面
*******************************************************************************************/
void bubbleSort(int a[])
{
   int i,j,t;
    for(i=0;i<ARRAYNUM;i++){
        for(j=i+1;j<ARRAYNUM;j++){
            if(a[i]>a[j]){
                swap(&a[i],&a[j]);                                 
            }              
        }  
    }
}
/******************************************************************************************
 *选择排序
 *每一趟从待排序的数据元素中选出最小）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
*******************************************************************************************/
void selectSort(int a[])
{
    int i,j,t,pos;
    for(i=0;i<ARRAYNUM;i++){
        pos=i;
        for(j=i+1;j<ARRAYNUM;j++){
            if(a[pos]>a[j]){
                pos=j;                                 
            }                  
        }
        if(pos !=i){
            swap(&a[i],&a[pos]);   
        }
    }
}

/******************************************************************************************
 *快速排序
 *过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法
 *对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
 *每次循环首先从右边查找到第一个比temp小的元素，然后替换a[i]，在从左边查找第一个比temp大的元素，然后替换a［j］，
 *替换后在把temp替成a［i］，从而完成顺序排列
*******************************************************************************************/
void quickSort(int a[],int left,int right)//快速排序第二种想法
{
    int i,j,temp;
    i=left;
    j=right;
    temp=a[left];
    if(left>right){
        return;
    }
    while(i!=j){
        while(a[j]>=temp && i<j){
            j--;
        }
        if(j>i){
            a[i]=a[j];
            i++;     
        }
        while(a[i]<=temp && i<j){
            i++;
        }
        if(j>i){
            a[j]=a[i];
            j--;
        }      
    }
    a[i]=temp;
    quickSort(a,left,i-1);
    quickSort(a,i+1,right);
}
/*
void quicksort(int a[],int startpoint ,int endpoint)//快速排序第一种想法
{
    int i,j,t;
    int key=startpoint;
    j=endpoint;
    i=startpoint+1;
    while(i<j){
        if(a[i]<a[key]){
            t=a[key];
            a[key]=a[i];
            a[i]=t;
            key=i;
            i++;
        }
        else{
            t=a[i];
            a[i]=a[j];
            a[j]=t;
            j--;           
        }
    }
    if((i-1)<=startpoint){
        quicksort(a ,0 ,i);
    }
    if((i+1)>=endpoint){
    quicksort(a , i+1,endpoint);
    }  
}
*/

/******************************************************************************************
 ＊插入排序
 *将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都
 *移动到有序区完成排序。
*******************************************************************************************/
void insertSort(int a[])//插入排序第二种想法
{
    int index=0;
    int temp=0;
    int temp_index=0;  
    for(index=1;index<ARRAYNUM;index++){
        temp=a[index];
        for(temp_index=index;(temp_index>0)&&(temp<a[temp_index-1]);temp_index--){
            a[temp_index]=a[temp_index-1];         
            a[temp_index-1]=temp;  
        }      
    }  
}
/*
void insertSort(int a[])//插入排序第一种想法
{
    int i,j,k,temp=0;
    for(i=1;i<ARRAYNUM;i++){
        for(j=0;j<i;j++){
            if(a[i]<a[j])
            {
                temp=a[i];
                for(k=i;k>=j;k--){
                    a[k]=a[k-1];                   

                }
                a[j]=temp;
                break;
            }
                       
        }
    }  
}
*/
/******************************************************************************************
 *希尔排序
 *先将序列按增量划分为元素个数相同的若干组，使用直接插入排序法进行排序，然后不断缩小增量直至为1，最后使用直接插
 *入排序完成排序。其中最总要的是步长的选择，目前已经存在的较优步长为gap＝gap＊3+1; 在大数据量中的较优步长为：
 *斐波那契数列除去0和1将剩余的数以黄金分割比的两倍的幂进行运算得到的数列
 *它是对插入排序法的改进
*******************************************************************************************/
void shellSort(int a[])//第二次的想法，即对第一次的想法的改进
{
    int gap=0;//步长，每组元素个数
    int temp_value=0;
    int i=0,j=0;
    while(gap<=ARRAYNUM){//计算合适的最大步长
        gap=gap*3+1;   
    }  
     while (gap > 0) {
         for ( i = gap; i < ARRAYNUM; i++ )
         {
             j = i - gap;//暗步长后所需排序组的初始位置
             temp_value = a[i];             
             while (( j >= 0 ) && ( a[j] > temp_value )){
                     a[j + gap] = a[j];
                     j = j - gap;
              }
             a[j + gap] = temp_value;
         }
         gap = ( gap - 1 ) /3;
     }   

}

/*
void shellSort(int a[])//第一次的想法,虽然也排出了正确结果，但是代码的实现和希尔排序算法是不一样的
{
    int gap=0;//步长，每组元素个数
    int countgroup=0;//在步长下所能分的组数
    int max_groupindex=0;//每组的最大坐标
    int min_groupindex=0;//每组的最小坐标
    int temp_value=0;
    int temp_index=0;
    int i=0,j=0;
    while(gap<=ARRAYNUM){//计算合适的最大步长
        gap=gap*3+1;   
    }  
    while(gap>0){//分组
        if(gap !=1){
            countgroup= (ARRAYNUM%gap==0 ? ARRAYNUM/gap :ARRAYNUM/gap+1);//计算在gap步长下有几个组
            for(i=1;i<=countgroup;i++){
                max_groupindex=((gap*i>ARRAYNUM) ? ARRAYNUM-1 : gap*i-1);//计算每组的最大坐标
                min_groupindex=(max_groupindex+1-gap<0 ?  gap*(i-1): max_groupindex+1-gap);//计算每组的最小坐标
                if(min_groupindex>=ARRAYNUM){
                    return ;
                }
                for(j=min_groupindex+1;j<=max_groupindex;j++){//在每组内使用插入排序
                    temp_value=a[j];
                    for(temp_index=j;(temp_index>min_groupindex)&&(temp_value<a[temp_index-1]);temp_index--){
                        a[temp_index]=a[temp_index-1];         
                        a[temp_index-1]=temp_value;
                    }                                          
                }
            }
        }
        else{
                min_groupindex=0;
                max_groupindex=ARRAYNUM-1;
                for(j=min_groupindex+1;j<=max_groupindex;j++){//在每组内使用插入排序
                    temp_value=a[j];
                    for(temp_index=j;(temp_index>min_groupindex)&&(temp_value<a[temp_index-1]);temp_index--){
                        a[temp_index]=a[temp_index-1];         
                        a[temp_index-1]=temp_value;
                    }                                          
                }
        }
        gap=(gap-1)/3;
    }  
}
*/

/******************************************************************************************
 *基数排序
 *将数位补起后先从最底位将数据分配到0－9个不同的“桶子”中，然后在按次低位排列，一直到最高位为止。
*******************************************************************************************/
void baseSort(int a[])
{

// 补齐位
    int temp[10][10]={0};
    int i=0;
    int length;
    int j=1;
    int max=0;
    int temp_value=a[0];
    int value=0;
    int k=0;
    for(i=1;i<ARRAYNUM;i++){//寻找最大值
        if(temp_value<a[i]){
            temp_value=a[i];
        }
    }  
    while((temp_value/j)>0){//寻找最大值长度
       
            j=j*10;
            max++;     
    }
    max=max-1;
    int index[10]={0};
    while(k<=max){

        int j=0;
        for(j=0;j<10;j++)
        index[j]=0;
        for(i=0;i<ARRAYNUM;i++){
            value=returnbitnum(a[i],k,max);
            temp[value][index[value]]=a[i];
            index[value]++;//记录value号桶中所包含元素的个数
        }
            int m,n=0,p;
            for(m=0;m<10;m++){
                    p=0;
                while(p<index[m]){
                    a[n]=temp[m][p];
                    n++;       
                    p++;
                }          
            }
        k++;
    }
}
int returnbitnum(int temp,int bit,int maxbit)
{
    int i=maxbit;
    int temp1=0;
    int temp2=temp;
    while(i>=bit)
    {
        temp1=temp2/power(10,i);
        temp2=temp2%power(10,i);
        if(bit==i&& i!=0)
            return temp1;
        if(bit==i&& i==0)
            return temp2;
        i--;
    }
}
int power(int x,int y)
{
    int i=1;
    int value=x;
    while(i<y){
        value=value*x; 
        i++;
    }
    return value;  
}