Python排序算法的实现

用Python实现了插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序、基数排序。

1、插入排序

描述

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。

代码实现

Python

1 2 3 4 5 6 7 8 9 10 11 12

def insert_sort ( lists ) :      # 插入排序      count = len ( lists )      for i in range ( 1 , count ) :          key = lists [ i ]          j = i - 1          while j >= 0 :              if lists [ j ] > key :                  lists [ j + 1 ] = lists [ j ]                  lists [ j ] = key              j -= 1      return lists

2、希尔排序

描述

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

代码实现

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

def shell_sort ( lists ) :      # 希尔排序      count = len ( lists )      step = 2      group = count / step      while group > 0 :          for i in range ( 0 , group ) :              j = i + group              while j < count :                  k = j - group                  key = lists [ j ]                  while k >= 0 :                      if lists [ k ] > key :                          lists [ k + group ] = lists [ k ]                          lists [ k ] = key                      k -= group                  j += group          group /= step      return lists

3、冒泡排序

描述

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

代码实现

Python

1 2 3 4 5 6 7 8

def bubble_sort ( lists ) :      # 冒泡排序      count = len ( lists )      for i in range ( 0 , count ) :          for j in range ( i + 1 , count ) :              if lists [ i ] > lists [ j ] :                  lists [ i ] , lists [ j ] = lists [ j ] , lists [ i ]      return lists

4、快速排序

描述

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

代码实现

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

def quick_sort ( lists , left , right ) :      # 快速排序      if left >= right :          return lists      key = lists [ left ]      low = left      high = right      while left < right :          while left < right and lists [ right ] >= key :              right -= 1          lists [ left ] = lists [ right ]          while left < right and lists [ left ] <= key :              left += 1          lists [ right ] = lists [ left ]      lists [ right ] = key      quick_sort ( lists , low , left - 1 )      quick_sort ( lists , left + 1 , high )      return lists

5、直接选择排序

描述

基本思想：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。

代码实现

Python

1 2 3 4 5 6 7 8 9 10

def select_sort ( lists ) :      # 选择排序      count = len ( lists )      for i in range ( 0 , count ) :          min = i          for j in range ( i + 1 , count ) :              if lists [ min ] > lists [ j ] :                  min = j          lists [ min ] , lists [ i ] = lists [ i ] , lists [ min ]      return lists

6、堆排序

描述

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

代码实现

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

def adjust_heap ( lists , i , size ) :      lchild = 2 * i + 1      rchild = 2 * i + 2      max = i      if i < size / 2 :          if lchild < size and lists [ lchild ] > lists [ max ] :              max = lchild          if rchild < size and lists [ rchild ] > lists [ max ] :              max = rchild          if max != i :              lists [ max ] , lists [ i ] = lists [ i ] , lists [ max ]              adjust_heap ( lists , max , size )   def build_heap ( lists , size ) :      for i in range ( 0 , ( size / 2 ) ) [ :: - 1 ] :          adjust_heap ( lists , i , size )   def heap_sort ( lists ) :      size = len ( lists )      build_heap ( lists , size )      for i in range ( 0 , size ) [ :: - 1 ] :          lists [ 0 ] , lists [ i ] = lists [ i ] , lists [ 0 ]          adjust_heap ( lists , 0 , i )

7、归并排序

描述

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

代码实现

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

def merge ( left , right ) :      i , j = 0 , 0      result = [ ]      while i < len ( left ) and j < len ( right ) :          if left [ i ] <= right [ j ] :              result . append ( left [ i ] )              i += 1          else :              result . append ( right [ j ] )              j += 1      result += left [ i : ]      result += right [ j : ]      return result   def merge_sort ( lists ) :      # 归并排序      if len ( lists ) <= 1 :          return lists      num = len ( lists ) / 2      left = merge_sort ( lists [ : num ] )      right = merge_sort ( lists [ num : ] )      return merge ( left , right )

8、基数排序

描述

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

代码实现

Python

1 2 3 4 5 6 7 8 9 10 11 12

import math def radix_sort ( lists , radix = 10 ) :      k = int ( math . ceil ( math . log ( max ( lists ) , radix ) ) )      bucket = [ [ ] for i in range ( radix ) ]      for i in range ( 1 , k + 1 ) :          for j in lists :              bucket [ j / ( radix * * ( i - 1 ) ) % ( radix * * i ) ] . append ( j )          del lists [ : ]          for z in bucket :              lists += z              del z [ : ]      return lists

7种排序算法：
1.选择排序
2.插入排序
3.冒泡排序
4.归并排序
5.快速排序
6.基数排序
7.计数排序
另外还有希尔，堆，桶排序，

[python] view plain copy

 print ?

1. # file :sort.py  
2.   
3. import math  
4.   
5. class sort:  
6.     def selectSort(self,L):  
7.         size = len(L)  
8.         for i in range(0,size):  
9.             max=L[i]  
10.             index = i  
11.             for j in range(i,size):  
12.                 if L[j] > max:  
13.                     max=L[j]  
14.                     index=j  
15.             temp = L[i]  
16.             L[i]=max  
17.             L[index]=temp  
18.             print(L)  
19.     def insertSort(self,L):  
20.         size = len(L)  
21.         for i in range(1,size):  
22.             fv = L[i]  
23.             j = i  
24.             while(j>=1):  
25.                 if fv < L[j-1]:  
26.                     L[j] = L[j-1]  
27.                 else:  
28.                     break  
29.                 j=j-1  
30.             L[j] = fv  
31.             print(L)  
32.     def bubbleSort(self,L):  
33.         size = len(L)  
34.         for i in range(size-1,-1,-1):  
35.             for j in range(0,i-1):#这里需要注意下，重新看下是否符合，感觉怪怪的  
36.                 if L[j]>L[j+1]:  
37.                     temp = L[j]  
38.                     L[j]=L[j+1]  
39.                     L[j+1] = temp  
40.             print(L)  
41.   
42.     def merge(self,L1,L2):  
43.         L=[]  
44.         index1 = 0  
45.         index2 = 0  
46.         size1 = len(L1)  
47.         size2 = len(L2)  
48.         top = min(size1,size2)  
49.         while(index1!=size1 and index2!=size2 ):  
50.             if L1[index1] > L2[index2]:  
51.                 L.append(L2[index2])  
52.                 index2 = index2 + 1  
53.             else:  
54.                 L.append(L1[index1])  
55.                 index1 = index1 + 1  
56.         if index1 < size1:  
57.             for i in range(index1,size1):  
58.                 L.append(L1[i])  
59.         if index2 < size2:  
60.             for i in range(index2,size2):  
61.                 L.append(L2[i])  
62.         return L  
63.     def mergeInL(self,L,first,mid,last):  
64.         tempa = []  
65.         tempb = []  
66.         for i in range(first,mid+1):  
67.             tempa.append(L[i])  
68.         for i in range(mid+1,last+1):  
69.             tempb.append(L[i])  
70.         tempc = self.merge(tempa,tempb)  
71.         index = 0  
72.         for i in range(first,last+1):  
73.             L[i] = tempc[index]  
74.             index += 1  
75.     #我错了。。。本来两个方法，写着写着变三个方法，改天再改  
76.     def mergeSort(self,L,first,last):  
77.         #print("1first = %d  last = %d" %(first,last))  
78.         if first < last:  
79.             #print("2first = %d  last = %d"%(first,last))  
80.             mid = math.trunc((first+last)/2) #必须拿到整数,晕死  
81.             self.mergeSort(L,first,mid)  
82.             self.mergeSort(L,mid+1,last)  
83.             self.mergeInL(L,first,mid,last)  
84.     #代码简洁效率高~~改天实现改进版的  
85.     def quickSort(self,L,left,right):  
86.         i = left  
87.         j = right  
88.         middle = L[left]  
89.         while i<=j:  
90.             while L[i]<middle and i<right:  
91.                 i += 1  
92.             while L[j]>middle and j>left:  
93.                 j -= 1  
94.             if i<=j: #命中一对  
95.                 temp = L[i]  
96.                 L[i] = L[j]  
97.                 L[j] = temp  
98.                 i += 1  
99.                 j += 1  
100.         if left<j:  
101.             self.quickSort(L,left,j)  
102.         if right > i:  
103.             self.quickSort(L,i,right)  
104.     def __bucketInit(self):  
105.         l0 = []  
106.         l1 = []  
107.         l2 = []  
108.         l3 = []  
109.         l4 = []  
110.         l5 = []  
111.         l6 = []  
112.         l7 = []  
113.         l8 = []  
114.         l9 = []  
115.         bucket = [l0,l1,l2,l3,l4,l5,l6,l7,l8,l9]  
116.         return bucket  
117.     #基数排序  
118.     def radixSort(self,L):  
119.         radix = 10  
120.         base = 1  
121.           
122.         bucket = self.__bucketInit()  
123.         max = L[0]  
124.         for i in L:  
125.             if i > max:  
126.                 max = i  
127.         while math.trunc((max%radix)/base) > 0:  
128.             #放到桶里  
129.             for i in L:  
130.                 index = math.trunc((i%radix)/base)  
131.                 bucket[index].append(i)  
132.             #重新整理回L  
133.             L = []  
134.             for i in bucket:  
135.                 L.extend(i)  
136.             bucket = self.__bucketInit()  
137.             print(L)  
138.             #下一轮循环取下一位  
139.             radix *= 10  
140.             base *=10  
141.         return L  
142.     #计数排序  
143.     def countSort(self,L):  
144.         size = len(L)  
145.         min = max = L[0]  
146.         #拿到最大和最小  
147.         for i in L:  
148.             if i<min:  
149.                 min = i  
150.             if i>max:  
151.                 max = i  
152.         #得到数字的区间  
153.         bound = max - min +1  
154.         #初始化计数数组  
155.         count =[]  
156.         for i in range(0,bound):  
157.             count.append(0)  
158.   
159.         #统计每个数出现的次数，放到count中  
160.         for i in range(0,size):  
161.             count[ L[i]-min ] +=1  
162.   
163.         z = 0  
164.         print("min = %d and max = %d"%(min,max))  
165.         for i in range(min,max+1):  
166.             #print("i="+str(i))  
167.             for j in range(0,count[i-min]):#count[i-min]表示该数字出现次数，0次地话不处理，多次的话依次插入  
168.                 #print("j="+str(j))  
169.                 L[z] = i  
170.                 print(L)  
171.                 z+=1  
172.         print(L)  
173.           
174.   
175.           
176.       
177.       
178.          
179.   
180.               
181.               
182.               
183.   
184.               
185. a = sort()  
186. l = [3,2,5,7,1,9]  
187. print('原始数组')  
188. print(l)  
189. print('选择排序')  
190. a.selectSort(l)  
191. l2 = [3,2,5,7,1,9]  
192. print('插入排序')  
193. a.insertSort(l2)  
194. print('冒泡排序')  
195. l3 = [3,2,5,7,1,9]   
196. a.bubbleSort(l3)  
197.   
198. print('列表归并算法 没有问题')  
199. la = [1,3,5,7,9,11]  
200. lb = [2,4,6,8]  
201. print(a.merge(la,lb))  
202. print('归并排序')  
203. lm = [3,2,5,7,1,9]  
204. a.mergeSort(lm,0,5)  
205. print(lm)  
206. print('快速排序')  
207. lq = [3,2,5,7,1,9]  
208. a.quickSort(lq,0,5)  
209. print(lq)  
210. print('基数排序')  
211. lr = [3,20,5,713,1,9]  
212. print(lr)  
213. a.radixSort(lr)  
214. print("计数排序")  
215. lz = [3,2,5,7,1,9]  
216. a.countSort(lz)  

运行结果: