/**
*前面七大排序为Kotlin，基数排序为java，在最后面
*/
fun main(array: Array){
val a = intArrayOf(2,5,3,7,9,8,1,6,4)
println("插入排序：")
insertSort(a).forEach {
println(it)
}
println("冒泡排序：")
bubbleSort(a).forEach {
println(it)
}
println("选择排序：")
selectedSort(a).forEach {
println(it)
}
println("希尔排序：")
shellSort(a).forEach {
println(it)
}
println("快速排序：")
quickSort1(a,0,a.size-1).forEach {
println(it)
}
println("归并排序")
mergeSort(a,0,a.size-1).forEach {
println(it)
}
println("堆排序")
heapSort(a).forEach {
println(it)
}
}
/**
* 插入排序，没什么好说的，数据越有序效率越好
*/
fun insertSort(s: IntArray): IntArray{
for(i in 1..(s.size-1)){
var temp = s[i]
var j = i-1
while (j >= 0 && temp1] = s[j]
j--
}
s[j+1] = temp
}
return s
}
/**
* 快速排序注意i 永远 不会等于 j，最后只会大于，即交叉
* 两种情况i=j，即数组所有元素全部有序，还有length=2
* 优化，到一定元素个数采取插入排序，或者采取三位取中，即从start,mid和end找出
*中间元素作为base，这样子能保证每次都是双边划分，而双边划分都是nlog2N的复杂度
*/
fun quickSort1(s: IntArray,left: Int,right: Int): IntArray{
if(left>=right) return s
val base = s[left]
var i=left+1
var j=right
while(i<=j){
while(s[i] <= base && i<=j){
i++
}
while(s[j] > base && i<=j){
j--
}
if(iif(s[left]>s[j]){
val temp = s[left]
s[left] = s[j]
s[j] = temp
}
quickSort1(s,left,j-1)
quickSort1(s,j+1,right)
return s
}
/**
*希尔排序，其实是插入排序。多了步长
*/
fun shellSort(s: IntArray): IntArray{
var n=s.size/2
while(n>=1){
for( j in n..(s.size-1)){
val temp = s[j]
var k = j-n
while(k>=0 && s[k]>temp){
s[k+n] = s[k]
k -= n
}
s[k+n] = temp
}
n/=2
}
return s
}
/**
* 选择排序，没什么好说的，性能最差
*/
fun selectedSort(s: IntArray): IntArray{
for(i in 0..(s.size-2)){
var index = i
for( j in i+1..(s.size-1)){
if(s[i] > s[j]){
index = j
}
}
if(index!=i){
val temp = s[i]
s[i] = s[index]
s[index] = temp
}
}
return s
}
/**
* 冒泡排序，特殊情况下可以达到O(n)，比如加个标记flag
*/
fun bubbleSort(s: IntArray):IntArray{
var flag = false
for (i in 0..(s.size-2)){
for(j in 0..(s.size-2-i)){
if(s[j] > s[j+1]){
val temp = s[j]
s[j] = s[j+1]
s[j+1] = temp
flag = true
}
}
if(!flag) break;
}
return s
}
/**
* 归并排序
*/
fun mergeSort(array: IntArray,start: Int,end: Int): IntArray{
if(start==end) return array
val mid=(start+end)/2
mergeSort(array,start,mid)
mergeSort(array,mid+1,end)
merge(array,start,mid,end)
return array
}
fun merge(array: IntArray,start: Int,mid: Int,end: Int){
val left = array.sliceArray(start..mid)
val right = array.sliceArray(mid+1..end)
var i=0
var j=0
for (k in start..end){
if(i==left.size){
array[k] = right[j]
j++
}else if(j==right.size){
array[k] = left[i]
i++
}else{
if(left[i]>right[j]){
array[k] = right[j]
j++
}else{
array[k] = left[i]
i++
}
}
}
}
/**
* 堆排序，主要分为堆化(建堆)和调整
*/
fun heapSort(array: IntArray): IntArray{
var end = array.size-1
initHeap(array,array.size)
swap(array,0,end)
end--;
while(end>0){
adjustHeap2(array,end,0)
swap(array,0,end)
end--;
}
return array
}
/**
* 堆排序堆化
*/
fun initHeap(array: IntArray,length: Int): IntArray{
if(length==1) return array
val m = length/2-1
for (k in m downTo 0 ){
adjustHeap2(array,array.size-1,k)
}
return array
}
/**
* 堆排序递归调整
*/
fun adjustHeap(array: IntArray,end: Int,index: Int){
val i = index
var j = 2 * i + 1
if (j >=end+1) return
if (j+11 && array[j]1]) j++
if (array[j]>array[i]){
swap(array,i,j)
adjustHeap(array,end,j)
}
}
/**
* 迭代调整
*/
fun adjustHeap2(array: IntArray,end: Int,index: Int){
var i = index
var j = 2*i +1
while(j1){
if(j+11 && array[j]1]) j++
if(array[j]>array[i]){
swap(array,i,j)
i = j
j = 2*i+1
}else{
break
}
}
}
fun swap(array: IntArray,i: Int,j:Int){
val temp = array[i]
array[i] = array[j]
array[j] = temp
}
##基数排序：Java
/**
* 基数排序
* 先分配到桶里面，再回收，再重置计数
* 重复d次，d为最大数的长度
* @author Shinelon
*/
public class RadixSort {
public static void main(String [] args) {
int [] array = {5,21,66,9512,152,477,888};
RadixSort radix = new RadixSort();
radix.executeRadixSort(array);
for(int i=0;ipublic void executeRadixSort(int [] array) {
int [] count = new int[10];
int [][] store = new int[10][array.length];
int temp = 0;
for(int i=0;iif(array[i]>temp) {
temp = array[i];
}
}
int d = Integer.valueOf(temp).toString().length();
for(int x=0;x
