基础算法（一）——八大排序算法实现Kotlin

/**
 *前面七大排序为Kotlin，基数排序为java，在最后面
 */
fun main(array: Array<String>){
    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 && temp<s[j]){
            s[j+1] = 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
    //比如数组长度为2，i=j
        while(i<=j){
            //i=j当数组有序的时候，此时划分是单边的，复杂度最高，为n*n
            while(s[i] <= base && i<=j){
                i++
            }
            while(s[j] > base && i<=j){
                j--
            }
            if(i<j){
                val temp = s[i]
                s[i] = s[j]
                s[j] = temp
            }

        }

    if(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
            }
        }
        //有序是O(n)
        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){
          //adjustHeap(array,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 ){
       // adjustHeap(array,array.size-1,k)
        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+1<end+1 && array[j]<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(j<end+1){
        if(j+1<end+1 && array[j]<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;i<array.length;i++) System.out.println(array[i]);
    }

    public void executeRadixSort(int [] array) {
        //每个桶存放的数的数量，初始化为0
        int [] count = new int[10];
        //所有桶的容量
        int [][] store = new int[10][array.length];

        //找出最大值
        int temp = 0;
        for(int i=0;i<array.length;i++) {
            if(array[i]>temp) {
                temp = array[i];
            }
        }
        //d为最大长度
        int d = Integer.valueOf(temp).toString().length();
        //d常数级
        for(int x=0;x<d;x++) {
            //开始分配行为
            for(int k=0;k<array.length;k++) {
                int g = getNumber(array[k],x);
                store[g][count[g]] = array[k];
                count[g]++;
            }       

            //开始回收行为
            int n = 0;
            for(int j=0;j<10;j++) {
                for(int k=0;k<count[j];k++) {
                    array[n] = store[j][k];
                    n++;
                }
                //重置本行的计数
                count[j]=0;
            }
        }
    }

    public int getNumber(int num,int q){
        int t = (int)Math.pow(10, q);
        int s =num/t%10;
        return s;
    }
}