The Algorithms of sort - Python

https://github.com/TheAlgorithms/Python；本文内容出自于此。

Sort Algorithms（排序算法）

Bubble（冒泡）

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

算法描述

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

由于它的简洁，冒泡排序通常被用来对于程序设计入门的学生介绍算法的概念。

特性：

最差时间复杂度：O(n^2)

最好时间复杂度：O(n)

平均时间复杂度：O(n^2)

Python代码实现：

 1 # Author:Sunshine
 2 
 3 testlist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14]
 4 
 5 def bubble(items):
 6     if len(items) <= 1:
 7         return items
 8     for index in range(len(items)-1,0,-1):
 9         flag = False
10         for sub_index in range(index):
11             if items[sub_index] > items[sub_index + 1]:
12                 items[sub_index],items[sub_index + 1] = items[sub_index + 1], items[sub_index]
13                 flag = True
14         if flag == False:
15             break
16     return items
17 
18 print('final:', bubble(testlist))
View Code

输出结果：final: [2, 4, 8, 13, 14, 26, 27, 28, 33, 35]

 

Insertion（插入）

维基百科：插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

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

如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找插入排序。

算法复杂度

如果目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需(n-1)次即可。最坏情况就是，序列是降序排列，那么此时需要进行的比较共有{\displaystyle {\frac {1}{2}}n(n-1)}次。插入排序的赋值操作是比较操作的次数减去(n-1)次，（因为n-1次循环中，每一次循环的比较都比赋值多一个，多在最后那一次比较并不带来赋值）。平均来说插入排序算法复杂度为O(n^{2})。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千；或者若已知输入元素大致上按照顺序排列，那么插入排序还是一个不错的选择。 插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为8个或以下）。

特性：

最差时间复杂度：O(n^2)

最好时间复杂度：O(n)

Python代码的两种实现：

# Author:Sunshine

testlist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14]

def insert_sort(lst):
    n=len(lst)
    if n==1: return lst
    for i in range(1,n):
        for j in range(i,0,-1):
            if lst[j]<lst[j-1]: lst[j],lst[j-1]=lst[j-1],lst[j]
    return lst

print('final:', insert_sort(testlist))
View Code
 1 # Author:Sunshine
 2 
 3 testlist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14]
 4 
 5 def insert_sort(lst):
 6     if len(lst) == 1:
 7         return lst
 8 
 9     for i in range(1, len(lst)):
10         temp = lst[i]
11         j = i - 1
12         while j >= 0 and temp < lst[j]:
13             lst[j + 1] = lst[j]
14             j -= 1
15         lst[j + 1] = temp
16     return lst
17 
18 print('final:', insert_sort(testlist))
View Code

输出结果：final: [2, 4, 8, 13, 14, 26, 27, 28, 33, 35]

 

Merge（归并排序）

维基百科：归并排序（英语：Merge sort，或mergesort），是创建在归并操作上的一种有效的排序算法，效率为O(n log n)。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。

归并操作

归并操作（merge），也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

迭代法

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

递归法

原理如下（假设序列共有n个元素）：

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

特性：

最差时间复杂度：O(nlogn)

最好时间复杂度：O(n)

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

Python代码的实现：

 1 # Author:Sunshine
 2 
 3 testlist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14]
 4 
 5 from collections import deque
 6 
 7 def merge_sort(lst):
 8     if len(lst) <= 1:
 9         return lst
10 
11     def merge(left, right):
12         merged,left,right = deque(),deque(left),deque(right)
13         while left and right:
14             merged.append(left.popleft() if left[0] <= right[0] else right.popleft())  # deque popleft is also O(1)
15         merged.extend(right if right else left)
16         return list(merged)
17 
18     middle = int(len(lst) // 2)
19     left = merge_sort(lst[:middle])
20     right = merge_sort(lst[middle:])
21     return merge(left, right)
22 
23 print('final:', merge_sort(testlist))
View Code

 

Quick（快速排序）

 

 维基百科：快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序n个项目要（大O符号）O(nlogn)次比较。在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他O(nlogn)算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

算法

 
快速排序采用“分而治之、各个击破”的观念，此为原地（In-place）分区版本。

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

步骤为：

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

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

在简单的伪代码中，此算法可以被表示为：

 function quicksort(q)
     var list less, pivotList, greater
     if length(q) ≤ 1 {
         return q
     } else {
         select a pivot value pivot from q
         for each x in q except the pivot element
             if x < pivot then add x to less
             if x ≥ pivot then add x to greater
         add pivot to pivotList
         return concatenate(quicksort(less), pivotList, quicksort(greater))
     }

特性：

最差时间复杂度：O(n^2)

最好时间复杂度：O(n)或O(nlogn)

平均时间复杂度：O(n^2)

Python代码的实现：

 1 def quicksort(lst, lo, hi):
 2  2      if lo < hi:
 3  3         p = partition(lst, lo, hi)
 4  4         quicksort(lst, lo, p)
 5  5         quicksort(lst, p+1, hi)
 6  6     return
 7  7 
 8  8 def partition(lst, lo, hi):
 9  9     pivot = lst[hi-1]
10 10     i = lo - 1
11 11     for j in range(lo, hi):
12 12         if lst[j] < pivot:
13 13             i += 1
14 14             lst[i], lst[j] = lst[j], lst[i]
15 15     if lst[hi-1] < lst[i+1]:
16 16         lst[i+1], lst[hi-1] = lst[hi-1], lst[i+1]
17 17     return i+1
View Code

 

Selection（选择排序）

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多（n-1）次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

特性：

最差时间复杂度：O(n^2)

最好时间复杂度：O(n^2)

平均时间复杂度：O(n^2)

Python代码的实现：

 1 def selection_sort(L):
 2     N = len(L)
 3     exchanges_count = 0
 4     for i in range(N-1):
 5         min_index = i
 6         for j in range(i+1, N):
 7             if L[min_index] > L[j]:
 8                 min_index = j
 9         if min_index != i:
10             L[min_index], L[i] = L[i], L[min_index]
11             exchanges_count += 1
12         print('iteration #{}: {}'.format(i, L))
13     print('Total {} swappings'.format(exchanges_count))
14     return L
15 
16 testlist = [17, 23, 20, 14, 12, 25, 1, 20, 81, 14, 11, 12]
17 print('Before selection sort: {}'.format(testlist))
18 print('After selection sort:  {}'.format(selection_sort(testlist)))
View Code

 

Shell（希尔排序）

维基百科：希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

  • 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
  • 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

算法实现

原始的算法实现在最坏的情况下需要进行O(n2)的比较和交换。V. Pratt的书对算法进行了少量修改，可以使得性能提升至O(n log2 n)。这比最好的比较算法的O(n log n)要差一些。

希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插入排序较快）。

假设有一个很小的数据在一个已按升序排好序的数组的末端。如果用复杂度为O(n2)的排序（冒泡排序或插入排序），可能会进行n次的比较和交换才能将该数据移至正确位置。而希尔排序会用较大的步长移动数据，所以小数据只需进行少数比较和交换即可到正确位置。

一个更好理解的希尔排序实现：将数组列在一个表中并对列排序（用插入排序）。重复这过程，不过每次用更长的列来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身仅仅对原数组进行排序（通过增加索引的步长，例如是用i += step_size而不是i++）。

例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ].这时10已经移至正确位置了，然后再以3为步长进行排序：

10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45

排序之后变为：

10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94

最后以1步长进行排序（此时就是简单的插入排序了）。

特性：

最差时间复杂度：O(n^2)

最好时间复杂度：O(n)

平均时间复杂度：取决于步长

Python代码的实现：

 1 def shell_sort(list):
 2     n = len(list)
 3     # 初始步长
 4     gap = n // 2
 5     while gap > 0:
 6         for i in range(gap, n):
 7             # 每个步长进行插入排序
 8             temp = list[i]
 9             j = i
10             # 插入排序
11             while j >= gap and list[j - gap] > temp:
12                 list[j] = list[j - gap]
13                 j -= gap
14             list[j] = temp
15         # 得到新的步长
16         gap = gap // 2
17     return list
View Code

 

 

冒泡，插入，选择排序的平均时间复杂度比较：

 

posted @ 2017-11-04 19:36  ZW_Sunshine  阅读(156)  评论(0)    收藏  举报