快速排序&基数排序

//快速排序
#include<stdio.h>

void QuickSort(int R[],int low,int high)
{
    int i=low,j=high;
    int pivot;
    if(low<high)
    {
        pivot=R[i];
        while(i!=j)
        {
            while(i!=j && R[j]>pivot)
                j--;
            R[i]=R[j];
            while(i!=j && R[i]<pivot)
                i++;
            R[j]=R[i];
        }
        R[i]=pivot;
        QuickSort(R,low,i-1);
        QuickSort(R,j+1,high);
    }

}

int main()
{
    int a[10]={0,1,7,2,5,4,3,6,8,9};
    int i;
    printf("原    ：");
    for(i=0;i<10;i++)
        printf("%d ",a[i]);
    printf("\n排序后：");
    QuickSort(a,0,9);
    for(i=0;i<10;i++)
        printf("%d ",a[i]);
    return 0;
}
//快速排序中用到递归，递归实质是一个循环
/*
while(条件)  //条件=递归出口
{
    function(变化的参数);
}
*/
//递归的思想是异级同构

//基数排序
#include<stdio.h>
// 乾卦
// 2014-5-3 
//获取数字的十位数
int get_ten(int n)
{
    return(n/10);

}
//获取数字的个位数
int get_single(int n)
{
    return (n%10);
}
int main()
{
    int arr[10][10]={0};   //存储索引,相同的数字最大存10个
    int ind_arr[10]={0};           //每行的存储长度
    int R[10]={12,21,13,98,91,94,42,32,56,79};
    int i,j,index;
    int k;
    //按个位数排序
    for(i=0;i<10;i++)
    {
        index=get_single(R[i]);    //获取每个数字的个位数
        arr[index][ind_arr[index]]=i;     //存储在R中的索引
        ind_arr[index]++;
    }
    //我们看看按照个位数排序后的输出
    printf("按照个位数排序：\n");
    for(i=0;i<10;i++)              
    {
        for(j=0;j<ind_arr[i];j++)    //先输出行
        {
            printf("%d ",R[arr[i][j]]);
        }
    }
    printf("\n");
    //遍历，整个数组然后从十位数最小的开始输出
    for(i=0;i<10;i++)                 //遍历10次
    {
        for(j=0;j<10;j++)
        {
            for(k=0;k<ind_arr[j];k++)
            {
                if(i==get_ten(R[arr[j][k]]))
                    printf("%d ",R[arr[j][k]]);

            }
            
        }

    }
    return 0;
}

可以用图表示上面的排序，跟前几篇的桶排序有相似的地方：

最上层的是arr数组的列索引，最左侧是arr数组的行索引，最右侧的是每行存储了多少个数，也就是ind_arr的值。

有黑色边框的表格里面的值的x:xx ，x代表数组R中的索引值，xx则是R[x]。

然后我们从头开始按顺序遍历10次(说遍历有点牵强，应该说遍历arr数组内值不为0的)，

每次取十位数值与遍历号相同的值输出。

此方法效率巨低。

那么我们可以考虑用空间换时间的方法。

//遍历，整个数组然后从十位数最小的开始输出
        for(j=0;j<10;j++)
        {
            for(k=0;k<ind_arr[j];k++)
            {
                //一共10个队列queue[x]
                queue[get_ten(R[arr[j][k]])].enQueue(R[arr[j][k]]);
                    
            }            
        }

我们一开始就可以用到这10个队列。很多书上有，不在此赘述。