冒泡排序，通过数组中一个值依次与数组内值进行比较交换，时间复杂度n*n

    fun sort(str: String) {
        val strs = str.toCharArray()
        var i = 0
        while (i < strs.size) {
            var j = i + 1
            while (j < strs.size) {
                if (strs[i] > strs[j]) {
                    var temp = strs[i]
                    strs[i] = strs[j]
                    strs[j] = temp
                }
                j++
            }
            i++
        }
        println(String(strs))
    }

选择排序，在冒泡基础上进行改进，通过位置记录最后一次排序的下标，省去频繁进行位置交换

    fun sortSelect(str: String) {
        val strs = str.toCharArray()
        var i = 0
        while (i < strs.size) {
            var j = i + 1
            var index = i
            while (j < strs.size) {
                if (strs[i] > strs[j]) {
                    index = j
                }
                j++
            }
            if (index != 0) {
                var temp = strs[i]
                strs[i] = strs[index]
                strs[index] = temp
            }
            i++
        }
        println(String(strs))
    }

插入排序，假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的

fun sortInsert(str: String) {
        val strs = str.toCharArray()
        var i = 1
        while (i < strs.size) {
            var j = i
            while (j > 0) {
                if (strs[j] < strs[j - 1]) {
                    var temp = strs[j]
                    strs[j] = strs[j - 1]
                    strs[j - 1] = temp
                }
                j--
            }
            i++
        }
        println(String(strs))
    }