Python实现排序（冒泡、快排、归并）

　　Thomas H.Cormen 的《算法导论》上介绍的几个经典排序算法的Python实现。

1、冒泡排序：

　　简单的两重循环遍历，使最小（最大）的值不断地往上升（下沉）而实现的排序，算法时间为O(n²)。

　　代码如下：

　　

 1 def up_sort(a):

 2         # 冒泡排序

 3 

 4         a_length = len(a)

 5         while True:

 6                 i = 0

 7                 j = 1

 8 

 9                 while True:

10                         if a[i] > a[j]:

11                                 a[i], a[j] = a[j], a[i]

12                                 i += 1

13                                 j = i+1

14                         else:

15                             i += 1

16                             j = i+1

17                         if j >= a_length:

18                                 break

19                 a_length -= 1

20                 if a_length == 1:

21                         break

 

2、快速排序

　　快排是一种使用较多的一种排序算法，对于包含n个数输入数组，最坏情况运行时间为Θ(n²)，期望运行时间为Θ(nlgn),而且常数因子较小，不容易出现最坏情况，所以快排常是进行排序的最佳选择。

　　其主要包括三个步骤(对子数组A[p...r])：

　　分解:数组A[p...r]被划分成两个子数组A[p..q-1]和A[q+1..r],使得A[p..q-1]中的元素都小于等于A[q]，而A[q+1..r]中的都大于A[q]

　　解决：通过递归调用快排，对数组A[p..q-1]和A[q+1..r]进行排序

　　合并：因为两个子数组是就地排序的，将他们的合并不需要操作：整个数组A[p..r]已排序

代码如下：

　　为排序一个完整的数组A，需调用quicksort(A,0,len[A]-1),partition()函数就是对子数组进行就地重排.

def partition(a, p, r):

    x = a[r]

    i = p-1

    for j in range(p, r-1):

        if a[j] <= x:



           i += 1

           a[i], a[j] = a[j], a[i]

    a[i+1], a[r] = a[r], a[i+1]

    return i+1





def quicksort(a, p, r):

    '快排'

    if p < r:

        q = partition(a, p, r)

        quicksort(a, p, q-1)

        quicksort(a, q+1, r)

        # print a

 

3、归并排序

　　归并排序是利用的分治的思想，讲一个要解决的问题划分为多个子问题，分别对每个子问题进行求解，算法直观的操作如下：

　　分解：将n个元素分解成各含n/2个元素的子序列；

　　解决：用合并排序法对两个子序列递归的排序

　　合并：合并两个已排序的子序列得到排序结果

代码如下：

归并排序的时间复杂度为Θ(nlgn)

 1 def merge_sort(a, p, r):

 2     '归并排序'

 3     if p < r:

 4         q = (p+r)//2

 5         merge_sort(a, p, q)

 6         merge_sort(a, q+1, r)

 7 

 8         merge(a, p, q, r)

 9 

10 

11 def merge(a, p, q, r):

12     n1 = q - p + 1

13     n2 = r - q

14     left = []

15     right = []

16     for i1 in range(0, n1):

17         left.append(a[p+i1])

18     for j1 in range(0, n2):

19         right.append(a[q+j1+1])

20 

21     left.append(float('inf'))

22     right.append(float('inf'))

23     i = 0

24     j = 0

25     for k in range(p, r+1):

26         if left[i] <= right[j]:

27             a[k] = left[i]

28             i += 1

29         else:

30             a[k] = right[j]

31             j += 1

 

4、完整代码：

　　包括实验的测试代码如下：

  1 # -*- coding: utf-8 -*-

  2 

  3 # !/usr/bin/env python

  4 

  5 

  6 __author__ = 'you'

  7 

  8 import random

  9 import time

 10 

 11 

 12 def up_sort(a):

 13         # 冒泡排序

 14 

 15         a_length = len(a)

 16         while True:

 17                 i = 0

 18                 j = 1

 19 

 20                 while True:

 21                         if a[i] > a[j]:

 22                                 a[i], a[j] = a[j], a[i]

 23                                 i += 1

 24                                 j = i+1

 25                         else:

 26                             i += 1

 27                             j = i+1

 28                         if j >= a_length:

 29                                 break

 30                 a_length -= 1

 31                 if a_length == 1:

 32                         # print a

 33                         break

 34 

 35 

 36 def partition(a, p, r):

 37     x = a[r]

 38     i = p-1

 39     for j in range(p, r-1):

 40         if a[j] <= x:

 41 

 42            i += 1

 43            a[i], a[j] = a[j], a[i]

 44     a[i+1], a[r] = a[r], a[i+1]

 45     return i+1

 46 

 47 

 48 def quicksort(a, p, r):

 49     '快排'

 50     if p < r:

 51         q = partition(a, p, r)

 52         quicksort(a, p, q-1)

 53         quicksort(a, q+1, r)

 54         # print a

 55 

 56 

 57 def merge(a, p, q, r):

 58     n1 = q - p + 1

 59     n2 = r - q

 60     left = []

 61     right = []

 62     for i1 in range(0, n1):

 63         left.append(a[p+i1])

 64     for j1 in range(0, n2):

 65         right.append(a[q+j1+1])

 66 

 67     left.append(float('inf'))

 68     right.append(float('inf'))

 69     i = 0

 70     j = 0

 71     for k in range(p, r+1):

 72         if left[i] <= right[j]:

 73             a[k] = left[i]

 74             i += 1

 75         else:

 76             a[k] = right[j]

 77             j += 1

 78 

 79 

 80 def merge_sort(a, p, r):

 81     '归并排序'

 82     if p < r:

 83         q = (p+r)//2

 84         merge_sort(a, p, q)

 85         merge_sort(a, q+1, r)

 86 

 87         merge(a, p, q, r)

 88         # print a

 89 

 90 

 91 if __name__ == '__main__':

 92         in_len = int(raw_input('输入排序个数：'))

 93         begin_num = int(raw_input('输入随机产生序列的范围：'))

 94         end_num = int(raw_input())

 95 

 96         A = []

 97         for i in range(0, in_len):

 98             A.append(random.randrange(begin_num, end_num))

 99             # print(A)

100         while True:

101             print '-'*10+'算法性能比较'+'-'*10

102             print '''

103             1、冒泡排序

104             2、快排

105             3、归并排序

106             0、退出

107             '''

108             print '-'*30

109             select=int(raw_input('输入选择'))

110             if select == 1:

111                 begin_time=time.time()

112 

113 

114                 up_sort(A)

115                 # print A

116                 end_time=time.time()

117             elif select == 0:

118                 break

119             elif select == 2:

120                 begin_time=time.time()

121                 quicksort(A, 0, len(A)-1)

122                 end_time=time.time()

123             else:

124                 begin_time=time.time()

125                 merge_sort(A, 0, len(A)-1)

126                 end_time=time.time()

127             print '该算法的耗时为:'+str((end_time-begin_time)*1000)+'ms'

完整代码