八大排序算法的 Python 实现

1. 1、插入排序  
2. def insert_sort(lists):  
3.     # 插入排序  
4.     count = len(lists)  
5.     for i in range(1, count):  
6.         key = lists[i]  
7.         j = i - 1  
8.         while j >= 0:  
9.             if lists[j] > key:  
10.                 lists[j + 1] = lists[j]  
11.                 lists[j] = key  
12.             j -= 1  
13.     return lists  
14.   
15. 2、希尔排序  
16. def shell_sort(lists):  
17.     # 希尔排序  
18.     count = len(lists)  
19.     step = 2  
20.     group = count / step  
21.     while group > 0:  
22.         for i in range(0, group):  
23.             j = i + group  
24.             while j < count:  
25.                 k = j - group  
26.                 key = lists[j]  
27.                 while k >= 0:  
28.                     if lists[k] > key:  
29.                         lists[k + group] = lists[k]  
30.                         lists[k] = key  
31.                     k -= group  
32.                 j += group  
33.         group /= step  
34.     return lists  
35.   
36. 3、冒泡排序  
37. def bubble_sort(lists):  
38.     # 冒泡排序  
39.     count = len(lists)  
40.     for i in range(0, count):  
41.         for j in range(i + 1, count):  
42.             if lists[i] > lists[j]:  
43.                 lists[i], lists[j] = lists[j], lists[i]  
44.     return lists  
45.   
46. 4、快速排序  
47. def quick_sort(lists, left, right):  
48.     # 快速排序  
49.     if left >= right:  
50.         return lists  
51.     key = lists[left]  
52.     low = left  
53.     high = right  
54.     while left < right:  
55.         while left < right and lists[right] >= key:  
56.             right -= 1  
57.         lists[left] = lists[right]  
58.         while left < right and lists[left] <= key:  
59.             left += 1  
60.         lists[right] = lists[left]  
61.     lists[right] = key  
62.     quick_sort(lists, low, left - 1)  
63.     quick_sort(lists, left + 1, high)  
64.     return lists  
65.   
66. 5、直接选择排序  
67. def select_sort(lists):  
68.     # 选择排序  
69.     count = len(lists)  
70.     for i in range(0, count):  
71.         min = i  
72.         for j in range(i + 1, count):  
73.             if lists[min] > lists[j]:  
74.                 min = j  
75.         lists[min], lists[i] = lists[i], lists[min]  
76.     return lists  
77.   
78. 6、堆排序  
79. # 调整堆  
80. def adjust_heap(lists, i, size):  
81.     lchild = 2 * i + 1  
82.     rchild = 2 * i + 2  
83.     max = i  
84.     if i < size / 2:  
85.         if lchild < size and lists[lchild] > lists[max]:  
86.             max = lchild  
87.         if rchild < size and lists[rchild] > lists[max]:  
88.             max = rchild  
89.         if max != i:  
90.             lists[max], lists[i] = lists[i], lists[max]  
91.             adjust_heap(lists, max, size)  
92. # 创建堆  
93. def build_heap(lists, size):  
94.     for i in range(0, (size/2))[::-1]:  
95.         adjust_heap(lists, i, size)  
96. # 堆排序  
97. def heap_sort(lists):  
98.     size = len(lists)  
99.     build_heap(lists, size)  
100.     for i in range(0, size)[::-1]:  
101.         lists[0], lists[i] = lists[i], lists[0]  
102.         adjust_heap(lists, 0, i)  
103.   
104. 7、归并排序  
105. def merge(left, right):  
106.     i, j = 0, 0  
107.     result = []  
108.     while i < len(left) and j < len(right):  
109.         if left[i] <= right[j]:  
110.             result.append(left[i])  
111.             i += 1  
112.         else:  
113.             result.append(right[j])  
114.             j += 1  
115.     result += left[i:]  
116.     result += right[j:]  
117.     return result  
118. def merge_sort(lists):  
119.     # 归并排序  
120.     if len(lists) <= 1:  
121.         return lists  
122.     num = len(lists) / 2  
123.     left = merge_sort(lists[:num])  
124.     right = merge_sort(lists[num:])  
125.     return merge(left, right)  
126.   
127. 8、基数排序  
128. import math  
129. def radix_sort(lists, radix=10):  
130.     k = int(math.ceil(math.log(max(lists), radix)))  
131.     bucket = [[] for i in range(radix)]  
132.     for i in range(1, k+1):  
133.         for j in lists:  
134.             bucket[j/(radix**(i-1)) % (radix**i)].append(j)  
135.         del lists[:]  
136.         for z in bucket:  
137.             lists += z  
138.             del z[:]  
139.     return lists