基本排序算法的Python实现



转自： http://python.jobbole.com/86119/ 

本篇主要实现九(八）大排序算法，分别是冒泡排序，插入排序，选择排序，希尔排序，归并排序，快速排序，堆排序,计数排序。希望大家回顾知识的时候也能从我的这篇文章得到帮助。

为了防止误导读者，本文所有概念性内容均截取自对应Wiki

冒泡排序

原理

冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

步骤

冒泡排序算法的运作如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码

1

2

3

4

5

6

7

8

9

10

defbubble_sort(list):

    length= len(list)

    # 第一级遍历

    forindex inrange(length):

        # 第二级遍历

        forj inrange(1,length -index):

            iflist[j- 1]> list[j]:

                # 交换两者数据，这里没用temp是因为python 特性元组。

                list[j- 1],list[j]= list[j],list[j- 1]

    returnlist

这种排序其实还可以稍微优化一下，添加一个标记，在排序已完成时，停止排序。

1

2

3

4

5

6

7

8

9

10

11

12

13

defbubble_sort_flag(list):

    length= len(list)

    forindex inrange(length):

        # 标志位

        flag= True

        forj inrange(1,length -index):

            iflist[j- 1]> list[j]:

                list[j- 1],list[j]= list[j],list[j- 1]

                flag= False

        ifflag:

            # 没有发生交换，直接返回list

            returnlist

    returnlist

选择排序

原理

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理大致是将后面的元素最小元素一个个取出然后按顺序放置。

步骤

1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 重复第二步，直到所有元素均排序完毕。

代码

1

2

3

4

5

6

7

8

9

defselection_sort(list):

    n=len(list)

  for iin range(0,n):

       min= i

      for jin range(i+1,n):

           iflist[j]<list[min]:

              min=j

               list[min],list[i]=list[i],list[min]

  return list

插入排序

原理

插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

步骤

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

代码

1

2

3

4

5

6

7

8

9

10

11

12

13

definsert_sort(list):

    n= len(list)

    fori inrange(1,n):

        # 后一个元素和前一个元素比较

        # 如果比前一个小

        iflist[i]  temp:

                    list[j+ 1]= list[j]

                    index= j

                else:

                    break

            # 插入元素

            list[index]= temp

    returnlist

希尔排序

原理

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

步骤

每次以一定步长(就是跳过等距的数)进行排序，直至步长为1.

代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

defshell_sort(list):

    n= len(list)

    # 初始步长

    gap= round(n/ 2)

    whilegap >0:

        fori inrange(gap,n):

            # 每个步长进行插入排序

            temp= list[i]

            j= i

            # 插入排序

            whilej >=gap andlist[j- gap]> temp:

                list[j]= list[j- gap]

                j-= gap

            list[j]= temp

        # 得到新的步长

        gap= round(gap/ 2)

    returnlist

步长使用的是Donald Shell的建议，另外步长还可以使用Sedgewick提出的(1, 5, 19, 41, 109,…)。
也可以使用斐波那契数列除去0和1将剩余的数以黄金分区比的两倍的幂进行运算得到的数列。

归并排序

原理

归并操作(归并算法)，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

步骤

迭代法

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针到达序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

递归法

假设序列共有n个元素：

1. 将序列每相邻两个数字进行归并操作，形成 {displaystyle floor(n/2)} floor(n/2)个序列，排序后每个序列包含两个元素
2. 将上述序列再次归并，形成 {displaystyle floor(n/4)} floor(n/4)个序列，每个序列包含四个元素
3. 重复步骤2，直到所有元素排序完毕

代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

# 递归法

def merge_sort(list):

    # 认为长度不大于1的数列是有序的

    iflen(list)<= 1:

        returnlist

    # 二分列表

    middle= len(list)//2

    left= merge_sort(list[:middle])

    right= merge_sort(list[middle:])

    # 最后一次合并

    returnmerge(left,right)

# 合并

defmerge(left,right):

    l,r=0,0

    result=[]

    whilel<len(left)and r<len(right):

        ifleft[l]<right[r]:

            result.append(left[l])

            l+=1

        else:

            result.append(right[r])

            r+=1

        reslut+=left[l:]

        result+=right[r:]                

    returnresult

鄙人不才，不知归并排序的迭代法如何用Python实现，望指教。

快速排序

原理

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

步骤

1. 从数列中挑出一个元素，称为”基准”（pivot），
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

代码

普通版

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

defquick_sort(list):

    less= []

    pivotList= []

    more= []

    # 递归出口

    iflen(list)<= 1:

        returnlist

    else:

        # 将第一个值做为基准

        pivot= list[0]

        fori inlist:

            # 将比急转小的值放到less数列

            ifi <pivot:

                less.append(i)

            # 将比基准打的值放到more数列

            elifi >pivot:

                more.append(i)

            # 将和基准相同的值保存在基准数列

            else:

                pivotList.append(i)

        # 对less数列和more数列继续进行排序

        less= quick_sort(less)

        more= quick_sort(more)

        returnless +pivotList +more

咳咳，下面这段代码出自《Python cookbook 第二版》传说中的三行实现python快速排序。

1

2

3

4

5

6

7

8

defqsort(arr):

    iflen(arr)<= 1:

        returnarr

    else:

        pivot= arr[0]

        returnqsort([xfor xin arr[1:]if x< pivot])+ \

              [pivot]+ \

               qsort([xfor xin arr[1:]if x>= pivot])

当然还有一行语法糖版本:

1

qs= lambdaxs :( (len(xs)<= 1and [xs])or [qs([xfor xin xs[1:]if x< xs[0]]) +[xs[0]]+ qs([xfor xin xs[1:]if x>= xs[0]]) ])[0]

是不是感受到了Python的魅力？

堆排序

原理

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

步骤

1. 创建最大堆:将堆所有数据重新排序，使其成为最大堆
2. 最大堆调整:作用是保持最大堆的性质，是创建最大堆的核心子程序
3. 堆排序:移除位在第一个数据的根节点，并做最大堆调整的递归运算

代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

defheap_sort(list):

    # 创建最大堆

    forstart inrange((len(list)- 2)//2,-1,-1):

        sift_down(list,start,len(list)- 1)

 

    # 堆排序

    forend inrange(len(list)- 1,0,-1):

        list[0],list[end]= list[end],list[0]

        sift_down(list,0,end -1)

    returnlist

 

 

# 最大堆调整

def sift_down(lst,start,end):

    root= start

    whileTrue:

        child= 2* root+ 1

        ifchild >end:

            break

        ifchild +1 <=end andlst[child]< lst[child+ 1]:

            child+= 1

        iflst[root]< lst[child]:

            lst[root],lst[child]= lst[child],lst[root]

            root= child

        else:

            break

计数排序

原理

当输入的元素是n个0到k之间的整数时，它的运行时间是Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。

由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序算法中，能够更有效的排序数据范围很大的数组。

步骤

1. 找出待排序的数组中最大和最小的元素
2. 统计数组中每个值为i的元素出现的次数，存入数组 C 的第 i 项
3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

代码

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

defcount_sort(list):

    min= 2147483647

    max= 0

    # 取得最大值和最小值

    forx inlist:

        ifx  max:

            max= x

    # 创建数组C

    count= [0]* (max- min+1)

    forindex inlist:

        count[index- min]+= 1

    index= 0

    # 填值

    fora inrange(max- min+1):

        forc inrange(count[a]):

            list[index]= a+ min

            index+= 1

    returnlist

第九种排序

None？
当然不会
自然就是系统自带的

1

list.sort()