Python练手之6种经典排序算法

  在入手了python之后，确实被它简单的特性和上手容易度震惊过。不过python和c语言什么的又确实存在很大的差别，习惯了c语言，使用python的时候多少还是有些不习惯。

  入手python一周左右了，为了熟悉和深化对python的理解，就把几种经典的排序算法拿来练手，顺便强化一下自己的基础知识。开始写了，才发现自己写出来的代码问题还真不少，排序的结果总是有各种问题，看来真的是很久没有用这些算法写过东西了，都忘了一些细节的东西了，汗哪。。。

  废话不多说，开始练手吧。

  排序前需要给定一个数据集，这个用随机数生成就好：

 

[python] view plain copy print ?

1. #-*- coding: utf-8 -*- 
2. #!/usr/bin/python 
3. #Filename:randata.py 
4. #Author: Boyce 
5. #Email:  boyce.ywr@gmail.com 
6. import random 
7. '''''
8. 随机生成0~10000000之间的数值
9. ''' 
10. def getrandata(num): 
11.     a=[] 
12.     i=0 
13.     while i<num: 
14.         a.append(random.randint(0,10000000)) 
15.         i+=1 
16.     return a 

#-*- coding: utf-8 -*- #!/usr/bin/python #Filename:randata.py #Author: Boyce #Email: boyce.ywr@gmail.com import random ''' 随机生成0~10000000之间的数值 ''' def getrandata(num): a=[] i=0 while i<num: a.append(random.randint(0,10000000)) i+=1 return a

  经典算法之冒泡排序（Bubble sort）：

 

[python] view plain copy print ?

1. #-*- coding: utf-8 -*- 
2. #!/usr/bin/python 
3. #Filename:bubble_sort.py 
4. #Author: Boyce 
5. #Email:  boyce.ywr@gmail.com 
6. import randata 
7. '''''
8. 算法思想：每次从最后开始往前滚，邻接元素两两相比，小元素交换到前面
9. 第一轮循环把最小的元素上浮至第一个位置，第二小的元素上浮至第二个位置，依次类推
10. ''' 
11. def bubbleSort(a): 
12.     l=len(a)-2 
13.     i=0 
14.     while i<l: 
15.         j=l 
16.         while j>=i: 
17.             if(a[j+1]<a[j]): 
18.                 a[j],a[j+1]=a[j+1],a[j] 
19.             j-=1 
20.         i+=1 

#-*- coding: utf-8 -*- #!/usr/bin/python #Filename:bubble_sort.py #Author: Boyce #Email: boyce.ywr@gmail.com import randata ''' 算法思想：每次从最后开始往前滚，邻接元素两两相比，小元素交换到前面 第一轮循环把最小的元素上浮至第一个位置，第二小的元素上浮至第二个位置，依次类推 ''' def bubbleSort(a): l=len(a)-2 i=0 while i<l: j=l while j>=i: if(a[j+1]<a[j]): a[j],a[j+1]=a[j+1],a[j] j-=1 i+=1

  经典算法之直接插入排序（Insert sort）：

 

[python] view plain copy print ?

1. #-*- coding: utf-8 -*- 
2. #!/usr/bin/python 
3. #Filename: insert_sort.py 
4. #Author: Boyce 
5. #Email:  boyce.ywr@gmail.com 
6. import randata 
7. '''''
8. 被注释掉的部分是c语言数组普通的插入方式
9. 未被注释的部分则是使用python列表的插入和删除特性改善的
10. ''' 
11. def insertSort(arr): 
12.     for i in range(1,len(arr)): 
13.         '''''
14.         tmp=arr[i]
15.         j=i
16.         while j>0 and tmp<arr[j-1]:
17.             arr[j]=arr[j-1]
18.             j-=1
19.         arr[j]=tmp
20.         ''' 
21.         j=i 
22.         while j>0 and arr[j-1]>arr[i]: 
23.             j-=1 
24.         arr.insert(j,arr[i]) 
25.         arr.pop(i+1) 

#-*- coding: utf-8 -*- #!/usr/bin/python #Filename: insert_sort.py #Author: Boyce #Email: boyce.ywr@gmail.com import randata ''' 被注释掉的部分是c语言数组普通的插入方式 未被注释的部分则是使用python列表的插入和删除特性改善的 ''' def insertSort(arr): for i in range(1,len(arr)): ''' tmp=arr[i] j=i while j>0 and tmp<arr[j-1]: arr[j]=arr[j-1] j-=1 arr[j]=tmp ''' j=i while j>0 and arr[j-1]>arr[i]: j-=1 arr.insert(j,arr[i]) arr.pop(i+1)

  经典算法之希尔排序（Shell sort）：

 

[python] view plain copy print ?

1. #-*- coding: utf-8 -*- 
2. #!/usr/bin/python 
3. #Filename: shell_sort.py 
4. #Author: Boyce 
5. #Email:  boyce.ywr@gmail.com 
6. import randata 
7. def shellSort(arr): 
8.     dist=len(arr)/2 
9.     while dist>0: 
10.         for i in range(dist,len(arr)): 
11.             tmp=arr[i] 
12.             j=i 
13.             while j>=dist and tmp<arr[j-dist]: 
14.                 arr[j]=arr[j-dist] 
15.                 j-=dist 
16.             arr[j]=tmp 
17.         dist/=2 

#-*- coding: utf-8 -*- #!/usr/bin/python #Filename: shell_sort.py #Author: Boyce #Email: boyce.ywr@gmail.com import randata def shellSort(arr): dist=len(arr)/2 while dist>0: for i in range(dist,len(arr)): tmp=arr[i] j=i while j>=dist and tmp<arr[j-dist]: arr[j]=arr[j-dist] j-=dist arr[j]=tmp dist/=2

  希尔排序的名称源于它的发明者Donald Shell，该算法是冲破二次时间屏障的第一批算法之一，不过，直到它最初被发现的若干年后才被证明了它的亚二次时间界。它通过比较相距一定间隔的元素来工作；各趟比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。

  经典算法之归并排序（Merge sort）：

 

[python] view plain copy print ?

1. #-*- coding: utf-8 -*- 
2. #!/usr/bin/python 
3. #Filename: merge_sort.py 
4. #Author: Boyce 
5. #Email:  boyce.ywr@gmail.com 
6. import randata 
7. '''''
8. 使用新分配的空间存储合并得到的新列表
9. arr：  原始列表（数组）
10. s：    需合并的第一段空间起始点
11. m：    需合并的第二段空间起始点
12. e：    需合并的第二段空间结束点
13. ''' 
14. def mergeWithNewSpace(arr,s,m,e): 
15.     i,j=s,m 
16.     t=0 
17.     newArr=[] 
18.     while i<m and j<=e: 
19.         if(arr[i]<arr[j]): 
20.             newArr.append(arr[i]) 
21.             i+=1 
22.             t+=1 
23.         else: 
24.             newArr.append(arr[j]) 
25.             j+=1 
26.             t+=1 
27.     if i>=m: 
28.         t=0 
29.         for i in range(s,j): 
30.             arr[i]=newArr[t] 
31.             t+=1 
32.     else: 
33.         t=0 
34.         for i in range(i,m): 
35.             newArr.append(arr[i]) 
36.         for i in range(s,e+1): 
37.             arr[i]=newArr[t] 
38.             t+=1 
39.     del newArr 
40. def mergePassWithNewSpace(arr, n, d): 
41.     i=0 
42.     while i<(n-d) and i<(n+1-2*d): 
43.         mergeWithNewSpace(arr,i,i+d,i+2*d-1) 
44.         i=i+2*d 
45.     if i<n-d: 
46.         mergeWithNewSpace(arr,i,i+d,n-1) 
47.     else: 
48.         mergeWithNewSpace(arr,i-2*d,i,n-1) 
49. def mergeSortWithNewSpace(arr): 
50.     d=1 
51.     while d<len(arr): 
52.         mergePassWithNewSpace(arr,len(arr),d) 
53.         d*=2 
54. '''''
55. 不分配新的空间存储合并得到的列表
56. 而是使用原列表使用插入方式存储
57. arr：  原始列表（数组）
58. s：    需合并的第一段空间起始点
59. m：    需合并的第二段空间起始点
60. e：    需合并的第二段空间结束点
61. 被注释掉的部分是c语言数组普通的插入方式
62. 未被注释的部分则是使用python列表的插入和删除特性改善的
63. ''' 
64. def mergeWithoutNewSpace(arr,s,m,e): 
65.     i,j=s,m 
66.     while i<m and j<=e: 
67.         if arr[i]>arr[j]: 
68.             '''''
69.             tmp=arr[j]
70.             k=j
71.             while k>i:
72.                 arr[k]=arr[k-1]
73.                 k-=1
74.             arr[i]=tmp
75.             ''' 
76.             arr.insert(i,arr[j]) 
77.             arr.pop(j+1) 
78.             j+=1 
79.             m+=1 
80.         else: 
81.             i+=1 
82. '''''
83. arr：  原始列表（数组）
84. n：    数组大小
85. d：    区间大小
86. ''' 
87. def mergePassWithoutNewSpace(arr, n, d): 
88.     i=0 
89.     while i<(n-d) and i<(n+1-2*d): 
90.         mergeWithoutNewSpace(arr,i,i+d,i+2*d-1) 
91.         i=i+2*d 
92.     if i<n-d: 
93.         mergeWithoutNewSpace(arr,i,i+d,n-1) 
94.     else: 
95.         mergeWithoutNewSpace(arr,i-2*d,i,n-1) 
96. def mergeSortWithoutNewSpace(arr): 
97.     d=1 
98.     while d<len(arr): 
99.         mergePassWithoutNewSpace(arr,len(arr),d) 
100.         d*=2 

#-*- coding: utf-8 -*- #!/usr/bin/python #Filename: merge_sort.py #Author: Boyce #Email: boyce.ywr@gmail.com import randata ''' 使用新分配的空间存储合并得到的新列表 arr： 原始列表（数组） s： 需合并的第一段空间起始点 m： 需合并的第二段空间起始点 e： 需合并的第二段空间结束点 ''' def mergeWithNewSpace(arr,s,m,e): i,j=s,m t=0 newArr=[] while i<m and j<=e: if(arr[i]<arr[j]): newArr.append(arr[i]) i+=1 t+=1 else: newArr.append(arr[j]) j+=1 t+=1 if i>=m: t=0 for i in range(s,j): arr[i]=newArr[t] t+=1 else: t=0 for i in range(i,m): newArr.append(arr[i]) for i in range(s,e+1): arr[i]=newArr[t] t+=1 del newArr def mergePassWithNewSpace(arr, n, d): i=0 while i<(n-d) and i<(n+1-2*d): mergeWithNewSpace(arr,i,i+d,i+2*d-1) i=i+2*d if i<n-d: mergeWithNewSpace(arr,i,i+d,n-1) else: mergeWithNewSpace(arr,i-2*d,i,n-1) def mergeSortWithNewSpace(arr): d=1 while d<len(arr): mergePassWithNewSpace(arr,len(arr),d) d*=2 ''' 不分配新的空间存储合并得到的列表 而是使用原列表使用插入方式存储 arr： 原始列表（数组） s： 需合并的第一段空间起始点 m： 需合并的第二段空间起始点 e： 需合并的第二段空间结束点 被注释掉的部分是c语言数组普通的插入方式 未被注释的部分则是使用python列表的插入和删除特性改善的 ''' def mergeWithoutNewSpace(arr,s,m,e): i,j=s,m while i<m and j<=e: if arr[i]>arr[j]: ''' tmp=arr[j] k=j while k>i: arr[k]=arr[k-1] k-=1 arr[i]=tmp ''' arr.insert(i,arr[j]) arr.pop(j+1) j+=1 m+=1 else: i+=1 ''' arr： 原始列表（数组） n： 数组大小 d： 区间大小 ''' def mergePassWithoutNewSpace(arr, n, d): i=0 while i<(n-d) and i<(n+1-2*d): mergeWithoutNewSpace(arr,i,i+d,i+2*d-1) i=i+2*d if i<n-d: mergeWithoutNewSpace(arr,i,i+d,n-1) else: mergeWithoutNewSpace(arr,i-2*d,i,n-1) def mergeSortWithoutNewSpace(arr): d=1 while d<len(arr): mergePassWithoutNewSpace(arr,len(arr),d) d*=2

  归并排序算法中，在合并两个已排序的表时，通常的做法是新建一个大小等于它们之和的新表，用于存储这两个表合并的结果，然后把把合并后的表在拷贝回这两个连续的表中。另外一个做法，也可以不分配新的空间存储结果，而是使用插入排序的思想进行合并。

  使用分配空间合并的方式，时间复杂度为O(nlogn)，使用插入合并的方式，时间复杂度为O(n^2)，这里采用python列表的插入和删除机制，比c语言中数组整体往后挪动的插入方式（见注释部分）要高效不少。

  经典算法之堆排序：

 

[python] view plain copy print ?

1. #-*- coding: utf-8 -*- 
2. #!/usr/bin/python 
3. #Filename:heap_sort.py 
4. #Author: Boyce 
5. #Email:  boyce.ywr@gmail.com 
6. '''''
7. 大根堆：在一棵完全二叉树中，对于任意节点，满足性质arr[i]>=arr[2*i], arr[i]>=arr[2*i+1]
8. 小根堆：在一棵完全二叉树中，对于任意节点，满足性质arr[i]<=arr[2*i], arr[i]<=arr[2*i+1]
9. ''' 
10. import randata 
11. '''''
12. 假定除了start位置的顶点外，以start位置为root的这棵二叉树是一个大根堆
13. 向下调整start位置的节点至合适的位置，是的这棵树重新恢复为一个大根堆
14. ''' 
15. def adjust(arr,start,size): 
16.     tmp=arr[start] 
17.     j=2*start+1 
18.     while j<size: 
19.         if j<size-1 and arr[j]<arr[j+1]: 
20.             j+=1 
21.         if tmp>=arr[j]: 
22.             break 
23.         arr[start]=arr[j] 
24.         start=j 
25.         j=2*j+1 
26.     arr[start]=tmp 
27. '''''
28. 从一堆乱序的元素列表中建立大根堆
29. ''' 
30. def buildHeap(arr): 
31.     size=len(arr) 
32.     for i in range(size/2-1,-1,-1): 
33.         adjust(arr,i,size) 
34. def heapSort(arr): 
35.     size=len(arr) 
36.     buildHeap(arr) 
37.     '''''
38.     建立大根堆后，第一个元素为列表的最大元素，将它跟最后一个元素交换，列表大小-1
39.     重新调整列表为大根堆，重复此操作直到最后一个元素
40.     ''' 
41.     for i in range(size-1,0,-1): 
42.         arr[i],arr[0]=arr[0],arr[i] 
43.         adjust(arr,0,i) 

#-*- coding: utf-8 -*- #!/usr/bin/python #Filename:heap_sort.py #Author: Boyce #Email: boyce.ywr@gmail.com ''' 大根堆：在一棵完全二叉树中，对于任意节点，满足性质arr[i]>=arr[2*i], arr[i]>=arr[2*i+1] 小根堆：在一棵完全二叉树中，对于任意节点，满足性质arr[i]<=arr[2*i], arr[i]<=arr[2*i+1] ''' import randata ''' 假定除了start位置的顶点外，以start位置为root的这棵二叉树是一个大根堆 向下调整start位置的节点至合适的位置，是的这棵树重新恢复为一个大根堆 ''' def adjust(arr,start,size): tmp=arr[start] j=2*start+1 while j<size: if j<size-1 and arr[j]<arr[j+1]: j+=1 if tmp>=arr[j]: break arr[start]=arr[j] start=j j=2*j+1 arr[start]=tmp ''' 从一堆乱序的元素列表中建立大根堆 ''' def buildHeap(arr): size=len(arr) for i in range(size/2-1,-1,-1): adjust(arr,i,size) def heapSort(arr): size=len(arr) buildHeap(arr) ''' 建立大根堆后，第一个元素为列表的最大元素，将它跟最后一个元素交换，列表大小-1 重新调整列表为大根堆，重复此操作直到最后一个元素 ''' for i in range(size-1,0,-1): arr[i],arr[0]=arr[0],arr[i] adjust(arr,0,i)

  堆排序的思路是建立在大根堆和小根堆的基础上，具体步骤可以参见网上解释以及上面的源码。

  经典算法之快速排序：

 

[python] view plain copy print ?

1. #-*- coding: utf-8 -*- 
2. #!/usr/bin/python 
3. #Filename:quick_sort.py 
4. #Author: Boyce 
5. #Email:  boyce.ywr@gmail.com 
6. import randata 
7. import sys 
8. '''''
9. 这个函数的作用是，从区间的第一个，最后一个和最中间的位置上选出一个中间大小的值，并把它放置在区间的第一个位置上
10. 这样有效消除预排序的最坏情况
11. ''' 
12. def median(a,start,end): 
13.     center=(start+end)/2 
14.     if a[start]>a[center]: 
15.         a[start],a[center]=a[center],a[start] 
16.     if a[start]>a[end]: 
17.         a[start],a[end]=a[end],a[start] 
18.     if a[center]>a[end]: 
19.         a[center],a[end]=a[end],a[center] 
20.     a[start],a[center]=a[center],a[start] 
21. def doSwap(a,start,end): 
22.     if start>=end: 
23.         return 
24.     i,j=start,end 
25.     median(a,start,end) 
26.     tmp=a[start] 
27.     while(True): 
28.         while(a[j]>tmp and i<j): 
29.             j-=1 
30.         if i<j: 
31.             a[i]=a[j] 
32.             i+=1 
33.         while(a[i]<tmp and i<j): 
34.             i+=1 
35.         if i<j: 
36.             a[j]=a[i] 
37.             j-=1 
38.         else: 
39.             break 
40.     a[i]=tmp 
41.     doSwap(a,start,i-1) 
42.     doSwap(a,j+1,end) 
43. def quickSort(a): 
44.     #设置递归深度为10000000，放置数据量过大时超出递归最大深度发生exception 
45.     sys.setrecursionlimit(1000000) 
46.     doSwap(a,0,len(a)-1) 

#-*- coding: utf-8 -*- #!/usr/bin/python #Filename:quick_sort.py #Author: Boyce #Email: boyce.ywr@gmail.com import randata import sys ''' 这个函数的作用是，从区间的第一个，最后一个和最中间的位置上选出一个中间大小的值，并把它放置在区间的第一个位置上 这样有效消除预排序的最坏情况 ''' def median(a,start,end): center=(start+end)/2 if a[start]>a[center]: a[start],a[center]=a[center],a[start] if a[start]>a[end]: a[start],a[end]=a[end],a[start] if a[center]>a[end]: a[center],a[end]=a[end],a[center] a[start],a[center]=a[center],a[start] def doSwap(a,start,end): if start>=end: return i,j=start,end median(a,start,end) tmp=a[start] while(True): while(a[j]>tmp and i<j): j-=1 if i<j: a[i]=a[j] i+=1 while(a[i]<tmp and i<j): i+=1 if i<j: a[j]=a[i] j-=1 else: break a[i]=tmp doSwap(a,start,i-1) doSwap(a,j+1,end) def quickSort(a): #设置递归深度为10000000，放置数据量过大时超出递归最大深度发生exception sys.setrecursionlimit(1000000) doSwap(a,0,len(a)-1)

  在这里，快速排序算法在选择参考值的时候，采用了中值选取的方式，即从区间的第一个，最后一个和最中间的元素，这三个中选择一个中间大小的作为参考值，把这个元素挪动至第一个位置。这个算法可以有效消除快速排序中的最坏时间复杂度。

  写出了算法，总要有个东西来验证，写一个单独的部分来执行这些算法，输出个算法花费的时间值，并将他们的执行结果输出至文件中，用于检验执行结果是否正确。

 

[python] view plain copy print ?

1. #-*- coding: utf-8 -*- 
2. #!/usr/bin/python 
3. #Filename:sort.py 
4. #Author: Boyce 
5. #Email:  boyce.ywr@gmail.com 
6. import time 
7. import randata 
8. import bubble_sort 
9. import quick_sort 
10. import heap_sort 
11. import shell_sort 
12. import merge_sort 
13. import insert_sort 
14. fileName='sort.dat' 
15. size=10000 
16. print '/nStart generate randam data...' 
17. arr=randata.getrandata(size) 
18. print 'Data generation finished.' 
19. print 'Data size is %d, result will be save to file %s'%(size,fileName) 
20. f=file(fileName,'w') 
21. f.write("/nOriginal data:/n") 
22. f.write(str(arr)) 
23. #使用python内置的timSort排序算法 
24. a=arr[:] 
25. print '/nStart internal sort...' 
26. t1=time.clock() 
27. a.sort() 
28. t2=time.clock() 
29. print 'Internal sort finisehd. Time used=%fs'%(t2-t1) 
30. f.write('/n/nInternal sort [Time used=%fs]/n'%(t2-t1)) 
31. f.write(str(a)) 
32. del a 
33. a=arr[:] 
34. print '/nStart quick sort...' 
35. t1=time.clock() 
36. quick_sort.quickSort(a) 
37. t2=time.clock() 
38. print 'Quick sort finished. Time used=%fs'%(t2-t1) 
39. f.write('/n/nQuick sort [Time used=%fs]/n'%(t2-t1)) 
40. f.write(str(a)) 
41. del a 
42. a=arr[:] 
43. print '/nStart heap sort...' 
44. t1=time.clock() 
45. heap_sort.heapSort(a) 
46. t2=time.clock() 
47. print 'Heap sort finished. Time used=%fs'%(t2-t1) 
48. f.write('/n/nHeap sort [Time used=%fs]/n'%(t2-t1)) 
49. f.write(str(a)) 
50. del a 
51. a=arr[:] 
52. print '/nStart shell sort...' 
53. t1=time.clock() 
54. shell_sort.shellSort(a) 
55. t2=time.clock() 
56. print 'Shell sort finished. Time used=%fs'%(t2-t1) 
57. f.write('/n/nShell sort [Time used=%fs]/n'%(t2-t1)) 
58. f.write(str(a)) 
59. del a 
60. a=arr[:] 
61. print '/nStart merge sort with new space...' 
62. t1=time.clock() 
63. merge_sort.mergeSortWithNewSpace(a) 
64. t2=time.clock() 
65. print 'Merge sort with new space finished. Time used=%fs'%(t2-t1) 
66. f.write('/n/nMerge sort with new space [Time used=%fs]/n'%(t2-t1)) 
67. f.write(str(a)) 
68. del a 
69. a=arr[:] 
70. print '/nStart merge sort without new space...' 
71. t1=time.clock() 
72. merge_sort.mergeSortWithoutNewSpace(a) 
73. t2=time.clock() 
74. print 'Merge sort without new space finished. Time used=%fs'%(t2-t1) 
75. f.write('/n/nMerge sort without new space [Time used=%fs]/n'%(t2-t1)) 
76. f.write(str(a)) 
77. del a 
78. a=arr[:] 
79. print '/nStart insert sort...' 
80. t1=time.clock() 
81. insert_sort.insertSort(a) 
82. t2=time.clock() 
83. print 'Insert sort finished. Time used=%fs'%(t2-t1) 
84. f.write('/n/nInsert sort [Time used=%fs]/n'%(t2-t1)) 
85. f.write(str(a)) 
86. del a 
87. a=arr[:] 
88. print '/nStart bubble sort...' 
89. t1=time.clock() 
90. bubble_sort.bubbleSort(a) 
91. t2=time.clock() 
92. print 'Bubble sort finished. Time used=%fs'%(t2-t1) 
93. f.write('/n/nBubble sort [Time used=%fs]/n'%(t2-t1)) 
94. f.write(str(a)) 
95. del a 
96. f.close() 

#-*- coding: utf-8 -*- #!/usr/bin/python #Filename:sort.py #Author: Boyce #Email: boyce.ywr@gmail.com import time import randata import bubble_sort import quick_sort import heap_sort import shell_sort import merge_sort import insert_sort fileName='sort.dat' size=10000 print '/nStart generate randam data...' arr=randata.getrandata(size) print 'Data generation finished.' print 'Data size is %d, result will be save to file %s'%(size,fileName) f=file(fileName,'w') f.write("/nOriginal data:/n") f.write(str(arr)) #使用python内置的timSort排序算法 a=arr[:] print '/nStart internal sort...' t1=time.clock() a.sort() t2=time.clock() print 'Internal sort finisehd. Time used=%fs'%(t2-t1) f.write('/n/nInternal sort [Time used=%fs]/n'%(t2-t1)) f.write(str(a)) del a a=arr[:] print '/nStart quick sort...' t1=time.clock() quick_sort.quickSort(a) t2=time.clock() print 'Quick sort finished. Time used=%fs'%(t2-t1) f.write('/n/nQuick sort [Time used=%fs]/n'%(t2-t1)) f.write(str(a)) del a a=arr[:] print '/nStart heap sort...' t1=time.clock() heap_sort.heapSort(a) t2=time.clock() print 'Heap sort finished. Time used=%fs'%(t2-t1) f.write('/n/nHeap sort [Time used=%fs]/n'%(t2-t1)) f.write(str(a)) del a a=arr[:] print '/nStart shell sort...' t1=time.clock() shell_sort.shellSort(a) t2=time.clock() print 'Shell sort finished. Time used=%fs'%(t2-t1) f.write('/n/nShell sort [Time used=%fs]/n'%(t2-t1)) f.write(str(a)) del a a=arr[:] print '/nStart merge sort with new space...' t1=time.clock() merge_sort.mergeSortWithNewSpace(a) t2=time.clock() print 'Merge sort with new space finished. Time used=%fs'%(t2-t1) f.write('/n/nMerge sort with new space [Time used=%fs]/n'%(t2-t1)) f.write(str(a)) del a a=arr[:] print '/nStart merge sort without new space...' t1=time.clock() merge_sort.mergeSortWithoutNewSpace(a) t2=time.clock() print 'Merge sort without new space finished. Time used=%fs'%(t2-t1) f.write('/n/nMerge sort without new space [Time used=%fs]/n'%(t2-t1)) f.write(str(a)) del a a=arr[:] print '/nStart insert sort...' t1=time.clock() insert_sort.insertSort(a) t2=time.clock() print 'Insert sort finished. Time used=%fs'%(t2-t1) f.write('/n/nInsert sort [Time used=%fs]/n'%(t2-t1)) f.write(str(a)) del a a=arr[:] print '/nStart bubble sort...' t1=time.clock() bubble_sort.bubbleSort(a) t2=time.clock() print 'Bubble sort finished. Time used=%fs'%(t2-t1) f.write('/n/nBubble sort [Time used=%fs]/n'%(t2-t1)) f.write(str(a)) del a f.close()

  这是某次执行的结果：

 

  输出结果被保存在当前目录的sort.dat文件中，用记事本打开即可看到。

  （看看人家python内置的timSort排序算法，根本就不是一个数量级的，真牛，好快呀。。。）

  这就是输出文件的内容显示：