算法基础复习-RadixSort

前言：为了后续的实习面试，开始疯狂刷题，非常欢迎志同道合的朋友一起交流。因为时间比较紧张，目前的规划是先过一遍，写出能想到的最优算法，第二遍再考虑最优或者较优的方法。如有错误欢迎指正。博主首发CSDN，mcf171专栏。

博客链接：mcf171的博客

——————————————————————————————
参考链接：基数排序
总体思路是：

基数排序的时间复杂度是O(k·n)，其中n是排序元素个数，k是数字位数。这个时间复杂度一定优于O(n·log(n))，k的大小取决于数字位的选择（比如比特位数），和待排序数据所属数据类型的全集的大小；k决定了进行多少轮处理，而n是每轮处理的操作数目。

以排序n个不同整数来举例，假定这些整数以B为底，这样每位数都有B个不同的数字，k = logB(N)，N是待排序数据类型全集的势。虽然有B个不同的数字，需要B个不同的桶，但在每一轮处理中，判断每个待排序数据项只需要一次计算确定对应数位的值，因此在每一轮处理的时候都需要平均n次操作来把整数放到合适的桶中去，所以就有：
k约等于logB(N)

所以，基数排序的平均时间T就是：
T～= logB(N)·n
其中前一项是一个与输入数据无关的常数，当然该项不一定小于logn

如果考虑和比较排序进行对照，基数排序的形式复杂度虽然不一定更小，但由于不进行比较，因此其基本操作的代价较小，而且在适当选择的B之下，k一般不大于logn，所以基数排序一般要快过基于比较的排序，比如快速排序。

public static void radixSort(int[] array){
if(array == null || array.length < 2) return;
int max = array[0];
for(int item: array) if(max < item) max = item;
int iterCount = 1;
while(max/10 != 0){ iterCount ++; max/=10;}
int[] count = new int[10];
List<List<Integer>> bucket = new ArrayList<List<Integer>>();
for(int j = 0 ; j < 10; j ++) bucket.add(new ArrayList<Integer>());
for(int i = 0 ; i < array.length; i ++){
bucket.get(array[i] % 10).add(array[i]);
count[array[i] % 10] ++;
}
int index = 1;
for(int i = 1; i < iterCount; i ++){
for(int j = 0; j < bucket.size(); j ++){
List<Integer> store = bucket.get(j);
int subScript = 0;
for(int k = 0; k < count[j]; k ++){
int value = getValue(index,store.get(0));
if(value != -1) {
bucket.get(value).add(store.get(0));
store.remove(subScript);
}else subScript ++;
}
}
index ++;
for(int j = 0; j < bucket.size();j ++) count[j] = bucket.get(j).size();
}
index = 0;
for(int i = 0; i < bucket.size(); i ++){
for(int item : bucket.get(i)){
array[index] = item;
index ++;
}
}

}

public static int getValue(int position,int value){

while(position > 0 && value > 0 ){
value = value/10;
position --;
}
return position >= 0 ? value % 10 : -1;
}