简单排序算法（kotlin实现）

1、希尔排序：

希尔排序是一个不稳定排序，他是在插入排序的基础上来做的，通过把数组分组，然后在进行比较，比较完以后进行交换位置。时间复杂度为n * log2 n  (n * log 以2为底 n 的对数)

import java.util.*/** * Created by chenpengfei on 17/9/14. */class ShellSortTest{}fun main(args: Array<String>){    var array = intArrayOf(10,20,11,45,24,6,7,43,2)    shellSort(array)    println(Arrays.toString(array))}fun shellSort(arry: IntArray){    var gap = arry.size/2    while(gap > 0){        println(gap)        for (j in gap..arry.size - 1 step 1){            var k = j - gap            while (k >= 0 && arry[k] > arry[k + gap]){                var temp = arry[k]                arry[k] = arry[k + gap]                arry[k + gap] = temp                k  -= gap            }        }        gap = gap /2 ;    }}

2、冒泡排序

冒泡是一个稳定排序算法，他的通过从数组的第一个或者最后一个值依次跟数组中其他的值进行比较，交换，确定一个最大值或者最小值。这样就把一个值的顺序排好了，这样执行数组n次的循环就可以把数组排序完成。时间复杂度为n * n

import java.util.*/** * Created by chenpengfei on 17/9/14. */fun  main(args : Array<String>){    var array = intArrayOf(10,20,11,45,24,6,7,43,2)    bubbleSort(array)    println(Arrays.toString(array))}fun bubbleSort(array :IntArray){    var i = 0;    while (i < array .size){        var j = i + 1;        while (j < array.size){            if(array[i] > array[j]){                var temp = array[i]                array[i] = array[j]                array[j] = temp            }            j ++        }        i ++;    }}

3、选择排序

选择排序也是稳定排序算法，他是在冒泡的基础上做的改进，因为冒泡比较完以后如果有需要就会进行交换，频繁的位置交换对于效率影响还是很大的，所以选择排序通过记录要交换的下标，在最后一次比较完以后做一次交换。
效率比冒泡排序高，但是时间复杂度还是n * n

import java.util.*/** * Created by chenpengfei on 17/9/14. */fun main(args: Array<String>){    var array = intArrayOf(10,20,11,45,24,6,7,43,2)    selectSort(array)    println(Arrays.toString(array))}fun selectSort(array : IntArray){    var i = 0    while (i < array.size){        var index = i //这个值用来判断当前最小值的下边是哪个，然后在后边进行交换        var j = i + 1;        while (j < array.size){            if(array[index] > array[j]){                index = j            }            j ++        }        if(index != 0){            var temp = array[i]            array[i] = array[index]            array[index] = temp        }        i++    }}

4、插入排序

插入排序也是一个稳定的排序算法，他的实现原理就是：假设现在前边n项是排好序的，那么把另外一个数插入比较以后插入进去，依然有序。他的时间复杂度也是n * n ,但是要比冒泡排序的效率高很多

import java.util.*/** * Created by chenpengfei on 17/9/14. */fun main (args : Array<String>){    var array = intArrayOf(10,20,11,45,24,6,7,43,2)    insertSort(array)    println(Arrays.toString(array))}fun  insertSort(array :IntArray){    var i = 1    while (i < array.size){        var j = i;        while (j > 0){            if(array[j] < array[j - 1]){                var temp = array[j]                array[j] = array[j -1]                array[j-1] = temp            }            j--        }        i ++    }}

5、堆排序

堆排序是基于二叉树来进行的，而且是一个完全平衡二叉树，通过构建最大堆或者最小堆，然后把二叉树的头结点跟最后一个结点交换，然后让二叉树中结点 1-(n -1)这几个结点依然保持最大堆或者最小堆，这样知道第一个结点跟第二个结点交换完成以后就是排好序的数组。堆排序是一个不稳定的排序算法。 时间复杂度是 n * log n