算法系列之--Javascript和Kotlin的希尔排序算法(原)

Posted 工程师阿杜

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了算法系列之--Javascript和Kotlin的希尔排序算法(原)相关的知识,希望对你有一定的参考价值。

上一节我们学习了插入算法,这一节来学习希尔排序算法,算法系列文章目录在这里


介绍


        希尔排序是 在插入排序基础上优化而来的,其思想就是利用插入排序最优时只需要O(n)的复杂度,我们可以对序列做调整,使其 尽可能靠近最优序列,然后不断运算插入算法。详细步骤如下:
        1. 挑选 合适的步长
        2. 以list[步长]为起点开始循环
        3. 有了起点, 以步长挑选一个子序列,并在子序列中进行插入排序
        4. 不断缩小步长


特点


        1、插入算法每次只能前进一步,而希尔算法可以让元素每次前进“一个步进”长度
        2、 先大跨步的运算插入算法,不断缩小步进长度,最终达到插入的最优效率


效率


        平均时间复杂度O(n log n)

        最坏时间复杂度O(n log^2 n)
        最优时间复杂度O(n log^2 n)


源码


Js源码


let list = [123456, 4, 8, 23, 5, 13, 323, 1, 9, 2, 3]
let temp, i, j, gap = 1
while (gap < list.length / 3) 
    //动态寻找合适的步长
    gap = gap * 3 + 1

for (; gap > 0; gap = Math.floor(gap / 3)) 
    for (i = gap; i < list.length; i++) 
        //temp就是当前选出来要插入的元素
        temp = list[i]
        for (j = i - gap; j >= 0; j = j - gap) 
            //这个for循环将以gap为步进挑选出来的list进行插入排序,temp就是当前list的起点元素
            if (list[j] <= temp) 
                break
            
            //让元素不断向后移动,寻找要插入的目标索引
            list[j + gap] = list[j]
        
        //将要插入的元素插入到目标位置
        list[j + gap] = temp
    


Kotlin源码


            private var ARRAY_COUNT = 100000
            /*
             * 获取随机数列
             */
            private fun getSortList(): IntArray 
                var sortList = IntArray(ARRAY_COUNT)
                var ra = Random()
                for (i in sortList.indices) 
                    sortList[i] = ra.nextInt(ARRAY_COUNT * 10)
                
                return sortList
            
            /*
             * 交换数列元素
             */
            private fun swapByIndex(list: IntArray, x: Int, y: Int) 
                var temp = list[x]
                list[x] = list[y]
                list[y] = temp
            
            /*
            希尔排序
             */
            private fun xier() 
                var sortList = getSortList()
                //Todo
                var gap = 1
                while (gap < sortList.size / 3) 
                    //寻找合适的步长
                    gap = gap * 3 + 1
                
                while (gap > 0) 
                    for (i in gap until sortList.size) 
                        var temp = sortList[i]
                        var j = i - gap
                        while (j >= 0) 
                            //将以temp为元素起点,以gap为步进长度构成的list进行插入运算
                            if (sortList[j] <= temp) 
                                break
                            
                            sortList[j + gap] = sortList[j]
                            j -= gap
                        
                        sortList[j + gap] = temp
                    
                    gap /= 3
                
            


        下一节我们来学习一种利用“堆”思想设计的高效的排序算法----堆排序算法

          各个算法的Kotlini版本性能测试结果请看算法系列之--Kotlin的算法实战比较


以上是关于算法系列之--Javascript和Kotlin的希尔排序算法(原)的主要内容,如果未能解决你的问题,请参考以下文章

算法系列之--Javascript和Kotlin的冒泡算法(原)

算法系列之--Javascript和Kotlin的基数排序算法(原)

算法系列之--Javascript和Kotlin的堆排序算法(原)

算法系列之--Javascript和Kotlin的希尔排序算法(原)

算法系列之--Javascript和Kotlin的快速排序算法(原)

算法系列之--Kotlin的算法实战比较(原)