基数排序 插入排序 希尔排序

基数排序

基数排序是一种来源于桶排序的思想，其核心是先排个位、再排十位、再排十位使其有序。

假设有一个无序数组 [8,22,98,103,44,78,93,171,13,42,61,18]，对其进行排序

分析

（1）先准备10个桶通过个位数放置所有的数；

（2）将数据依次取出，通过一轮排序，个位数就变得有序了；

（3）仍然通过十个桶按十位进行排序；

（4）排完序后依次将数据取出，此时十位数有序；

（5）对百位进行排序，其中只有103和171具有百位，因此将103和171放入“1”桶，其他的放入“0”桶并取出，然后取出103和171，完成排序。

代码实现

（1）创建一个二维数组来代替“桶”，该二维数组的一个维度是10，另一个维度的高度是需要排序的数组的长度。

int[][] bucker=new int[10][arr.length];

(2)遍历arr数组，对10取余获取各个数的个位数，并插入数据。

为了确认数据放在纵向维度上的位置，创建一个以一维数组作为桶计数器。

for(int i=0;i<arr.length;i++){
    int element = arr[i]%10; //确定横向存储在哪个桶中
    int[] bucketCount=new int[arr.length];
    int count=bucketCount[element];
    bucket [element] [count] = arr[i];
    bucketCount[element]=++bucketCount[element];
}

（3）将数据取出

for(int j=0;j<10;j++){
    if(bucketCount[j]!=0){
        int count=bucketCount[j];
        for(int k=0;k<count;k++){
            arr[j+k]=bucket[j][k];
        }
    }
}

完整代码如下：

public static void main(String[]args) {
    int[] arr= new int[]{4,13,8,27,69,7312,0,3,287,143,46,5,19,9,7,2};
    System.out.println("未排序数组： "+Arrays.toString(arr));
    Sort(arr);
    System.out.println("已排序数组： "+Arrays.toString(arr));
}
public static void Sort(int[]arr) {
    int[][] bucket=new int[10][arr.length];//定义桶
    int[] bucketCount=new int[arr.length];//定义桶计数器
        
    //找最大的数
    int max=arr[0];
    for(int i=0;i<arr.length;i++) {
        if(arr[i]>max) {
            max=arr[i];
        }
    }
        
    //取最大的数的位数，以确定后续要进行几次除10
    int maxLength=1;
    while(max>0) {
        max=max/10;
        maxLength*=10;
    }
        
    //排序过程
    //确定遍历各位数的循环次数
    for(int t=1;t<maxLength;t=t*10) {

        //把数放入桶
        for(int j=0;j<arr.length;j++) {
            int a=arr[j]/t%10;
            int count=bucketCount[a];
            bucket[a][count]=arr[j];
            bucketCount[a]=bucketCount[a]+1;
        }
            
        //把数从桶里取出来
        int i=0;
        for(int j=0;j<10;j++) {
            int count=bucketCount[j];
            if(count!=0) {
                for(int k=0;k<count;k++) {
                    arr[i]=bucket[j][k];//清空桶
                    i++;
                }
            }
            bucketCount[j]=0;//清空桶计数器
        }
    }    
}
/*
输出结果：
未排序数组： [8, 22, 98, 103, 44, 78, 93, 171, 13, 42, 61, 18]
已排序数组： [8, 13, 18, 22, 42, 44, 61, 78, 93, 98, 103, 171]
*/

插入排序

分析

插入排序是一种简单的排序方式，基本思想就是利用冒泡排序的基本思想进行简单的插入。

（1）首先我们认为待排序数组的第一个位置是已经排好序了，将剩下的数据依次插入到当前待排序数组当中。

（2）定义一个游标 i 指向待排序的数据，如果需要将待排序的数据排到左边，就利用冒泡排序的倒用

（3）定义另一个游标 j = i - 1，同时也会存在 j+1，j +1指向的数比 j 指向的数小，进行交换，然后 j-- 再次对比交换，就可以将前面的数变得有序了

（4）然后 i 游标就继续向后走，令 j 游标永远和 i 游标相差 1。

（5）重复上述步骤，当 i 游标完成数组的遍历后，数组就变得有序了。

代码实现

public static void main(String[]args) {
    int[] arr= new int[]{4,13,8,27,69,0,3,287,143,46,5,19,9,7,2};
    System.out.println("未排序数组： "+Arrays.toString(arr));
    Sort(arr);
    System.out.println("已排序数组： "+Arrays.toString(arr));
}
public static void Sort(int[]arr) {
    for(int i=1;i<arr.length;i++) {
        for(int j=i-1;j>=0;j--) {
            if(arr[j]>arr[j+1]) {
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
}
/*
输出结果：
未排序数组： [4, 13, 8, 27, 69, 0, 3, 287, 143, 46, 5, 19, 9, 7, 2]
已排序数组： [0, 2, 3, 4, 5, 7, 8, 9, 13, 19, 27, 46, 69, 143, 287] 
*/

插入排序存在的问题

当小数据在后面的时候，插入排序移动次数明显增多，对排序效率产生严重影响。

希尔排序

希尔排序（缩小增量排序）是为了解决插入排序的问题而创造的，其思想是通过分组尽可能让小的数往前走，让大的数往后走。

分析

（1）以数组长度的一半为步长进行分组；

（2）进行组内排序；

（3）步长进行折半再次进行分组；

（4）进行组内排序

（5）重复上述步骤直到最后将整个数组分为一组，再进行排序就相当于一个简单的插入排序了。

代码实现

public static void main(String[]args) {
    int[] arr= new int[]{4,13,8,27,69,0,3,287,143,46,5,19,9,7,2};
    System.out.println("未排序数组： "+Arrays.toString(arr));
    Sort(arr);
    System.out.println("已排序数组： "+Arrays.toString(arr));
}
public static void Sort(int[]arr) {
    for(int length=arr.length/2;length>0;length=length/2) {
        for(int i=length;i<arr.length;i++) {
            for(int j=i-length;j>=0;j-=length) {
                if(arr[j]>arr[j+length]) {
                    int temp=arr[j];
                    arr[j]=arr[j+length];
                    arr[j+length]=temp;
                }
            }
        }
    }
    }
 /*
输出结果：
未排序数组： [4, 13, 8, 27, 69, 0, 3, 287, 143, 46, 5, 19, 9, 7, 2]
已排序数组： [0, 2, 3, 4, 5, 7, 8, 9, 13, 19, 27, 46, 69, 143, 287] 
*/