排序算法总结

排序算法大致分为两种：

• 一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。
• 另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。

冒泡

package com.qy.algorithm

import java.util.*


/**
 * 冒泡算法
 */
class Bubble {

    companion object {

        fun BubbleSort(arr: Array<Int>) {
            for (i in 0 until arr.size - 1) {
                for (j in 0 until arr.size - 1 - i) {
                    if (arr[j] > arr[j + 1]) { //相邻两个元素作比较，如果前面元素大于后面，进行交换
                        val temp = arr[j + 1]
                        arr[j + 1] = arr[j]
                        arr[j] = temp
                    }
                }
            }
        }


        fun sort(array: Array<Int>) {
            var tmp = 0
            //记录最后一次交换的位置
            var lastExchangeIndex = 0
            //无序数列的边界，每次比较只需要比到这里为止
            var sortBorder = array.size - 1
            for (i in array.indices) {
                //有序标记，每一轮的初始是true

                var isSorted = true
                for (j in 0 until sortBorder) {
                    if (array[j] > array[j + 1]) {
                        tmp = array[j]
                        array[j] = array[j + 1]
                        array[j + 1] = tmp
                        //有元素交换，所以不是有序，标记变为false
                        isSorted = false
                        //把无序数列的边界更新为最后一次交换元素的位置
                        lastExchangeIndex = j
                    }
                }
                sortBorder = lastExchangeIndex
                if (isSorted) {
                    break
                }
            }
        }

        fun swip(array: Array<Int>, i: Int, j: Int) {
            var temp = array[i]
            array[i] = array[j]
            array[j] = temp
        }

        fun swap(arr: Array<Int>, i: Int, j: Int) {
            arr[i] = arr[i] xor arr[j]
            arr[j] = arr[i] xor arr[j]
            arr[i] = arr[i] xor arr[j]
        }


        fun bubbleSort(arr: Array<Int>) {
            var end = arr.size - 1
            while (end > 0) {
                var border = 0
                for (i in 0 until end) {
                    if (arr[i] > arr[i + 1]) {
                        swap(arr, i, i + 1)
                        border = i + 1
                    }
                }
                end = border
                end--
            }
        }


        /*鸡尾酒冒泡排序*/
        fun cocktailSort(arr: Array<Int>) {
            var L = 0
            var R = arr.size - 1;
            while (L < R) {
                for (i in L until R) if (arr[i] > arr[i + 1]) swap(arr, i, i + 1)
                R--;
                for (i in R downTo L + 1) if (arr[i] < arr[i - 1]) swap(arr, i, i - 1)
                L++;
            }
        }

    }


}

fun main(args: Array<String>) {
    val arr = arrayOf(1, 3, 100, 99, 77, 6, 38, 56)
    println("${Arrays.toString(arr)}")
    Bubble.cocktailSort(arr)
    println("${Arrays.toString(arr)}")
}

选择排序

package com.qy.algorithm

import java.util.*

class Choose {
     private fun chooseSort(arr: Array<Int>) {
        for (i in arr.indices) {
            var minIndex = i;
            for (j in i + 1 until arr.size) {
                minIndex = if (arr[j] < arr[minIndex]) j else minIndex
                var temp = arr[i]
                arr[i] = arr[minIndex]
                arr[minIndex] = temp
            }
        }
    }

    companion object {

        @JvmStatic
        fun main(args: Array<String>) {
            val arr = arrayOf(1, 3, 100, 99, 77, 6, 38, 56)
            val choose = Choose()
            println("${Arrays.toString(arr)}")
            choose.chooseSort(arr)
            println("${Arrays.toString(arr)}")
        }

    }


}