import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Sort {
// 打印函数
public static void print(int[] numbers) {
for (int i = 0; i < numbers.length; i++) {
System.out.print(numbers[i] + " ");
}
System.out.println();
}
/**
* 基数排序
*/
public static void radixSort(int[] numbers) {
int n = 1;
int k = 0;
int len = numbers.length;
int max = numbers[0];
for (int i = 0; i < len; i++) {
if (max < numbers[i]) {
max = numbers[i];
}
}
// 计算出需要比较到位数
int times = 0;
while (max != 0) {
times++;
max /= 10;
}
// 二维数组的行为按0-9形成的桶,len取number.length是保证桶能够放下所有的数字
int[][] bucket = new int[10][len];
// 用于保存每个桶里元素的个数
int[] order = new int[10];
while (n <= times) {
for (int num : numbers) {
int digit = num / (int) Math.pow(10, n - 1) % 10;
bucket[digit][order[digit]] = num;
order[digit]++;
}
for (int i = 0; i < len; i++) {
// 如果桶里有数据,从上到下遍该桶历并保存到原数组中
if (order[i] != 0) {
for (int j = 0; j < order[i]; j++) {
numbers[k] = bucket[i][j];
k++;
}
}
order[i] = 0; //将桶里计数器置0,用于下一位排序
}
n++;
k = 0;
}
}
/**
* 基数排序
* 时间复杂度为O(nlog(r)m),其中r为所采取的基数,而m为堆数
*/
public static int[] RadixSort(int[] array) {
if (array == null || array.length < 2)
return array;
// 1.先算出最大数的位数;
int max = array[0];
for (int i = 1; i < array.length; i++) {
max = Math.max(max, array[i]);
}
int maxDigit = 0;
while (max != 0) {
max /= 10;
maxDigit++;
}
int mod = 10, div = 1;
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < 10; i++)
bucketList.add(new ArrayList<Integer>());
for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
for (int j = 0; j < array.length; j++) {
int num = (array[j] % mod) / div;
bucketList.get(num).add(array[j]);
}
int index = 0;
for (int j = 0; j < bucketList.size(); j++) {
for (int k = 0; k < bucketList.get(j).size(); k++)
array[index++] = bucketList.get(j).get(k);
bucketList.get(j).clear();
}
}
return array;
}
/**
* 桶排序
* 被排序的数组内的数值是均匀分配的时候,桶排序时间复杂度(Ο(n))
*/
public static List<Integer> BucketSort(List<Integer> array, int bucketSize) {
if (array == null || array.size() < 2)
return array;
int max = array.get(0), min = array.get(0);
// 找到最大值最小值
for (int i = 0; i < array.size(); i++) {
if (array.get(i) > max)
max = array.get(i);
if (array.get(i) < min)
min = array.get(i);
}
int bucketCount = (max - min) / bucketSize + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
ArrayList<Integer> resultArr = new ArrayList<>();
for (int i = 0; i < bucketCount; i++) {
bucketArr.add(new ArrayList<Integer>());
}
for (int i = 0; i < array.size(); i++) {
bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
}
for (int i = 0; i < bucketCount; i++) {
if (bucketCount == 1)
bucketSize--;
List<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
for (int j = 0; j < temp.size(); j++)
resultArr.add(temp.get(j));
}
return resultArr;
}
/**
* 计数排序
* 空间换时间
* 时间复杂度为Ο(n+k)(其中k是整数的范围)
*/
public static int[] CountingSort(int[] array) {
if (array.length == 0) return array;
int bias, min = array[0], max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max)
max = array[i];
if (array[i] < min)
min = array[i];
}
bias = 0 - min;
int[] bucket = new int[max - min + 1];
Arrays.fill(bucket, 0);
for (int i = 0; i < array.length; i++) {
bucket[array[i] + bias]++;
}
int index = 0, i = 0;
while (index < array.length) {
if (bucket[i] != 0) {
array[index] = i - bias;
bucket[i]--;
index++;
} else
i++;
}
return array;
}
public static void main(String[] args) {
int[] numbers = new int[]{278, 109, 63, 930, 589, 184, 505, 269, 8, 83};
List<Integer> list = new ArrayList<>();
list.add(278);
list.add(109);
list.add(298);
list.add(28);
//桶排序测试
System.out.println(BucketSort(list, 100));
//计数排序测试
CountingSort(numbers);
print(numbers);
//基数排序测试
radixSort(numbers);
print(numbers);
}
}