圈排序——python

所谓的圈的定义,我只能想到用例子来说明,实在不好描述

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第一部分

第一步,我们现在来观察待排数组和排完后的结果,以及待排数组的索引,可以发现

排完序后的6应该出现在索引4的位置上,而它现在却在位置0上,

记住这个位置啊,一直找到某个数应该待在位置0上我们的任务就完成了

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第二步,而待排数组索引4位置上的5应该出现在索引3的位置上

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第三步,同样的,待排数组索引3的位置是1,1应该出现在位置0上,注意注意,找到这么一个数了:1,它应该待在位置0上

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第四步,而索引0处却放着6,而6应该出现在索引4的位置,至此可以发现,回到原点了,问题回到第一步了,

所以这里并不存在所谓的第四步,前三步就已经转完一圈了

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

这就是所谓的一圈!真不好描述,不知道您看明白没…汗.

前三步转完一圈,得到的数据分别是[ 6 5 1 ]

第二部分

第一步,圈排序并不是一圈排序,而一圈或多圈排序,所以,还得继续找,这一步从第二个数字2处开始转圈

待排中的2位于索引1处,排序完毕仍然处于位置1位置,所以这一圈完毕,得到圈数据[ 2 ]

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第三部分

第一步,同上,4也出现了它应该待的位置,结束这一圈,得到第三个圈:[ 4 ]

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

第四部分

第一步,由于1和5出现在第一圈里,这是什么意思呢,说明这两个数已经有自己的圈子了,不用再找了,

即是找,最后还是得到第一圈的数据[ 6 5 1 ],所以,1和5跳过,这一部分实际应该找的是9,来看看9的圈子

9应该出现在索引5的位置,实际上它就在索引5的位置,与第二部分的第一步的情况一样,所以这一圈的数据也出来了:[ 9 ]

待排数组[ 6 2 4 1 5 9 ]

排完序后[ 1 2 4 5 6 9 ]

数组索引[ 0 1 2 3 4 5 ]

一共找到四个圈子,分别是

[ 6 5 1 ] , [ 2 ] ,[ 4 ] , [ 9 ]

如果一个圈只有一个数字,那么它是不需要转圈的,即不需要排序,那么只有第一个圈排序即可

你可能要问了,前边的那些圈子都是基于已知排序结果才能得到,我都已知结果还排个毛啊

以上内容都是为了说明什么是圈,知道什么是圈后才能很好的理解圈排序

现在来分解排序的细节

第一步,将6取出来,计算出有4个数字比6小,将6放入索引4,同时原索引4位置的数字5出列

排序之前[ 0 2 4 1 5 9 ] 6

排序之后[ 0 2 4 1 6 9 ] 5

索引位置[ 0 1 2 3 4 5 ]

第二步,当前数字5,计算出有3个数字比5小,将5放入索引3,同时原索引3位置的数字

排序之前[ 0 2 4 1 6 9 ] 5

排序之后[ 0 2 4 5 6 9 ] 1

索引位置[ 0 1 2 3 4 5 ]

第三步,当前数字1,计算出有0个数字比1小,将1放入索引0,索引0处为空,这圈完毕

排序之前[ 0 2 4 5 6 9 ] 1

排序之后[ 1 2 4 5 6 9 ]

索引位置[ 0 1 2 3 4 5 ]

第一个圈[ 6 5 1 ]完毕

第四步,取出下一个数字2,计算出有1个数字比2小,将2放入索引1处,发现它本来就在索引1处

第五步,取出下一个数字4,计算出有2个数字比4小,将4放入索引2处,发现它本来就在索引2处

第六步,取出下一个数字5,5在第一个圈内,不必排序

第七步,取出下一个数字6,6在第一个圈内,不必排序

第八步,取出下一个数字9,计算出有5个数字比9小,将9放入索引5处,发现它本来就在索引5处

全部排序完毕
以上算法讲解来自kkun

from __future__ import print_function


def cycle_sort(array):
    """
    圈排序（不稳定排序）
    默认升序
    计数排序是另开辟空间存放排序结果，圈排序是不开辟空间，直接进行组内交换
    
    """
    ans = 0   #记录发生交换的次数，不用在意，无关紧要，可删

    #外层循环处理列表中的每一个圈，一次遍历出现一个圈
    for cycleStart in range(0, len(array) - 1):
        item = array[cycleStart]   #取出待排序的元素，item一直记录一圈的元素

        # 找到item应该放的位置，跟计数排序相似，统计列表中有多少个元素比item小
        pos = cycleStart #记录位置
        for i in range(cycleStart + 1, len(array)):
            if array[i] < item:
                pos += 1

        # item也存在圈但这个圈只有它自己，表示item已经归位，不用改变
        if pos == cycleStart:
            continue  #跳过本次循环继续下次循环

        # 这四行代码是处理列表中相同的元素
        while item == array[pos]:#如果相同，就直接放在pos的后一个位置
            pos += 1
        array[pos], item = item, array[pos]#item最终归位，并把item赋新值
        ans += 1

        #处理新的item
        while pos != cycleStart:#pos=cycleStart就代表又回到了起点，表示已有元素归到
                                #cycleStart位置上，一圈处理完毕

            # 以下代码跟上面思路一样
            pos = cycleStart
            for i in range(cycleStart + 1, len(array)):
                if array[i] < item:
                    pos += 1


            while item == array[pos]:
                pos += 1
            array[pos], item = item, array[pos]
            ans += 1

    return ans



if __name__ == '__main__':
    try:
        raw_input          # Python 2
    except NameError:
        raw_input = input  # Python 3
        
    user_input = raw_input('输入待排序的数，用\",\"分隔:\n').strip()
    #strip() 方法用于移除字符串头尾指定的字符（默认为空格）
    unsorted = [int(item) for item in user_input.split(',')]
    n = len(unsorted)
    cycle_sort(unsorted)

    print("排序后 : ")
    for i in range(0, n):
        print(unsorted[i], end=' ')

一些说明：

• 我的github项目上有完整的算法代码，欢迎star,fork.
• 这里的所有算法均用python实现，“翻译”自国外某程序员的项目。