数据结构排序-------基数排序（C，Java实现）

 1、基数排序简要概述

  （1）基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucketsort）或binsort，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用。
  （2）将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

 2、基数排序图解

  注意：先判断有无负数，有负数时处理思路：有则找到最小值，数组所有数据都减去该值，也就是数组最小值会变为0，接下来按正整数排序，最后数组所有数据加上原最小数，变为原有数据值。
基数排序图解：

 3、代码实现(不包含负数)

public class test {
    public static void main(String[] args) {
        int array[] = new int[]{20, 1, 18, 101, 319, 88};
        System.out.print("基数(桶)排序前：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        radixSort(array);
        System.out.println();
        System.out.print("基数(桶)排序后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }

    public static void radixSort(int a[]) {
        //用二维数组来表示桶
        int bucket[][] = new int[10][a.length];
        //用一维数组来表示桶中元素的个数
        //比如eleCounts[0]记录第0个桶中元素的个数
        int eleCounts[] = new int[10];
        int max = a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        int maxLength = (max + "").length(); //记录最大数的位数

        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            for (int j = 0; j < a.length; j++) {
                int digit = a[j] / n % 10;
                bucket[digit][eleCounts[digit]] = a[j];
                eleCounts[digit]++;
            }
            int index = 0;
            for (int k = 0; k < eleCounts.length; k++) {
                if (eleCounts[k] != 0) {
                    for (int l = 0; l < eleCounts[k]; l++) {
                        a[index++] = bucket[k][l];
                    }
                }
                eleCounts[k] = 0;
            }
        }
    }
}

结果如下：

 4、java代码实现(包含负数)

public class test {
    public static void main(String[] args) {
        int array[] = new int[]{20, -1, -18, 101, 319, 88};
        System.out.print("基数(桶)排序前：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        //因为有负数，所以先找到最小数(-18);
        int min = array[0];
        for (int i = 0; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }
        }
        //数组所有数据都减去该值
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] - min;
        }
        radixSort(array);
        //按正整数排序，最后数组所有数据加上原最小数(-18)
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] + min;
        }
        System.out.println();
        //进过排序后，要在该数组的基础上，加上最小值
        System.out.print("基数(桶)排序后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }

    public static void radixSort(int a[]) {
        //用二维数组来表示桶
        int bucket[][] = new int[10][a.length];
        //用一维数组来表示桶中元素的个数
        //比如eleCounts[0]记录第0个桶中元素的个数
        int eleCounts[] = new int[10];
        int max = a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        int maxLength = (max + "").length(); //记录最大数的位数

        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            for (int j = 0; j < a.length; j++) {
                int digit = a[j] / n % 10;
                bucket[digit][eleCounts[digit]] = a[j];
                eleCounts[digit]++;
            }
            int index = 0;
            for (int k = 0; k < eleCounts.length; k++) {
                if (eleCounts[k] != 0) {
                    for (int l = 0; l < eleCounts[k]; l++) {
                        a[index++] = bucket[k][l];
                    }
                }
                eleCounts[k] = 0;
            }
        }
    }
}

结果如下：

 5、C代码实现(不包含负数)

#include <stdio.h>
int main(int argc, char *argv[])
{
	void radixSort(int a[],int len);
	int arr[]={20, 1, 18, 101, 319, 88};
	//得到数组的长度 
	int length=sizeof(arr)/sizeof(arr[0]);
	printf("基数(桶)排序前：");
	for (int i = 0; i < length; i++) {
            printf("%d ",arr[i]);
        }
 	radixSort(arr,length);
 	printf("\n");
 	printf("基数(桶)排序后：");
	for (int i = 0; i < length; i++) {
            printf("%d ",arr[i]);
        }
	printf("\n");
	return 0;
}
void radixSort(int a[],int len){
	   //用二维数组来表示桶
        int bucket[10][len] ;
        //记录最大数的位数
        int maxLength=0;
        //用一维数组来表示桶中元素的个数
        //比如eleCounts[0]记录第0个桶中元素的个数
        int eleCounts[10]={0,0,0,0,0,0,0,0,0,0};
        int max = a[0];
        for (int i = 1; i < len; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        do{
        	maxLength++;
        	max/=10;
        }while(max>0);
        for (int i = 0, n = 1; i < maxLength; i++, n*=10) {
            for (int j = 0; j < len; j++) {
                int digit = a[j] / n % 10;
                bucket[digit][eleCounts[digit]] = a[j];
                eleCounts[digit]++;
            }
            int index = 0;
            int eleCountsLength=sizeof(eleCounts)/sizeof(eleCounts[0]);
	          for (int k = 0; k < eleCountsLength; k++) {
                if (eleCounts[k] != 0) {
                    for (int l = 0; l < eleCounts[k]; l++) {
                        a[index++] = bucket[k][l];
                    }
                }
                eleCounts[k] = 0;
            }  
        }
}

结果如下：

 6、C代码实现(包含负数)

#include <stdio.h>
int main(int argc, char *argv[])
{
	void radixSort(int a[],int len);
	int arr[]={20, -1, -18, 101, 319, 88};
	//得到数组的长度 
	int length=sizeof(arr)/sizeof(arr[0]);
	printf("基数(桶)排序前：");
	for (int i = 0; i < length; i++) {
            printf("%d ",arr[i]);
        }
 
	//因为有负数，所以先找到最小数(-18);
        int min = arr[0];
        for (int i = 0; i < length; i++) {
            if (min > arr[i]) {
                min = arr[i];
            }
        }
 	//数组所有数据都减去该值
        for (int i = 0; i < length; i++) {
            arr[i] = arr[i] - min;
        }
 	radixSort(arr,length);
 	//按正整数排序，最后数组所有数据加上原最小数(-18)
        for (int i = 0; i < length; i++) {
            arr[i] = arr[i] + min;
        }
 	printf("\n");
 	printf("基数(桶)排序后：");
	for (int i = 0; i < length; i++) {
            printf("%d ",arr[i]);
        }
	printf("\n");
	return 0;
}
void radixSort(int a[],int len){
	   //用二维数组来表示桶
        int bucket[10][len] ;
        //记录最大数的位数
        int maxLength=0;
        //用一维数组来表示桶中元素的个数
        //比如eleCounts[0]记录第0个桶中元素的个数
        int eleCounts[10]={0,0,0,0,0,0,0,0,0,0};
        int max = a[0];
        for (int i = 1; i < len; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        do{
        	maxLength++;
        	max/=10;
        }while(max>0);
        for (int i = 0, n = 1; i < maxLength; i++, n*=10) {
            for (int j = 0; j < len; j++) {
                int digit = a[j] / n % 10;
                bucket[digit][eleCounts[digit]] = a[j];
                eleCounts[digit]++;
            }
            int index = 0;
            int eleCountsLength=sizeof(eleCounts)/sizeof(eleCounts[0]);
	          for (int k = 0; k < eleCountsLength; k++) {
                if (eleCounts[k] != 0) {
                    for (int l = 0; l < eleCounts[k]; l++) {
                        a[index++] = bucket[k][l];
                    }
                }
                eleCounts[k] = 0;
            }  
        }
}

结果如下：

---

楠哥-------一心想为IT行业添砖加瓦，却总是面向cv编程的程序员。
  谢谢阅读，无误点赞，有误还望评论区指正。

---