常见排序算法（简单排序）

简单排序算法实现

冒泡排序(Bubble Sort)

object BubbleSort {

    @JvmStatic
    fun main(args: Array<String>) {
        val a = intArrayOf(24, 12, 36, 22)
        val sort = BubbleSort.sort(a)
        for (i in sort) {
            println(i.toString() + ", ")
        }
    }

    //循环判断当前数是否大于后面一位，如果是交换位置
    fun sort(a: IntArray): IntArray {
        var x: Int
        for (i in a.indices) {
            for (j in 0 until a.size - 1) {
                if (a[j] > a[j + 1]) {
                    x = a[j + 1]
                    a[j + 1] = a[j]
                    a[j] = x
                }
            }
        }
        return a
    }
}

选择排序

在已排序好的数据中插入待排序数据

17,12,4,5
    -> 12,17,4,5
     ->12,17,17,5 |12,12,17,5
      ->4,12,17,5

object InsertSort{

      fun main(args: Array<String>){
           val s:IntArray= intArrayOf(78, 12, 4, 9, 13)
           val ints:IntArray = sort(s)
           println(ints.contentToString())
    }

      fun sort(a: IntArray):IntArray{
              var i = 1
              var j : Int
              var x = 0

              while(i < a.size){
                    x = a[i]
                    j = i
                    while(j > 0 &&  a[j-1] > x){
                          a[j] = a[j-1]
                          --j
                    }
                    a[j] = k
                    i++
            }
                return a
      }
}

快速排序

object QuickSort {

    @JvmStatic
    fun main(args: Array<String>) {
        val array = intArrayOf(7, 3, 2, 23, 67, 5, 6)
        sort(array, 0, 6)
        println(Arrays.toString(array))
    }

    /**
     * 7,3,2,23,67,5,6
     * 6,3,2,23,67,5,6
     * 6,3,2,23,67,5,23
     * 6,3,2,7,67,5,23
     *
     */
    fun sort(array: IntArray, l: Int, r: Int) {
        if (l < r) {
            var i: Int
            var j: Int
            val k: Int
            i = l
            j = r
            k = array[i]//选择基数

            while (i < j) {
                //从右往左选择小于k的值
                while (i < j && array[j] > k)
                    j--
                if (i < j) {
                    array[i++] = array[j] //array[i] = array[j]
                }
                //从左往右选择大于k的值
                while (i < j && array[i] < k)
                    i++
                if (i < j) {
                    array[j--] = array[i]
                }

            }
            array[i] = k
            sort(array, l, i - 1) /* 递归调用 */
            sort(array, i + 1, r) /* 递归调用 */
        }

    }
｝

选择排序

未排序的数列中找到最小(or最大)元素，然后将其存放到数列的起始位置；
从左比较最小那一个

object SelectSort{

    @JvmStatic
    fun main(args: Array<String>) {
        val a = intArrayOf(12, 9, 8, 26, 5, 6)

        val sort = sort(a)
        for (c in sort) {
            print(c.toString() + ", ")

        }
    }

        fun sort(a:IntArray):IntArray{
            var x : Int
            for(i in a.indices){
                for(j in i +1 until a.size){
                        x = a[j]
                        if(a[j] < a[i]){
                              array[j] = array[i]
                              array[i] = x
                      }
                }
            }
            return a
      }
}