1 '''
  2 Created on 2016/12/16
  3 Created by freeol.cn
  4 一些排序算法的Python实现
  5 @author: 拽拽绅士
  6 '''
  7
  8 '''值交换'''
  9 def swap(m, n):
 10     c = m; m = n; n = c;
 11     return m, n
 12
 13 '''冒泡排序
 14 特征：
 15 稳定排序算法
 16 最坏时间复杂度O(n^2)
 17 平均时间复杂度O(n^2)
 18 空间复杂度O(1)
 19 总结：重复的相邻元素进行比较交换，越大的元素
 20 会经由交换慢慢“浮”到数列的顶端'''
 21 def bubbleSort(a):
 22     for i in range(0, len(a)):
 23         for j in range(0, len(a)-i-1):
 24             if a[j] > a[j+1]:
 25                 a[j], a[j+1] = swap(a[j],a[j+1])
 26     return a
 27
 28 '''选择排序
 29 特征：
 30 不稳定排序算法
 31 最坏时间复杂度O(n^2)
 32 平均时间复杂度O(n^2)
 33 空间复杂度O(1)
 34 总结：重复的选择后面最小的与遍历到的位置交换'''
 35 def selectSort(a):
 36     for i in range(0, len(a)-1):
 37         min = i
 38         for j in range(i+1, len(a)):
 39             if a[j] < a[min]:
 40                 min = j
 41         a[i], a[min] = swap(a[i], a[min])
 42     return a
 43
 44 '''插入排序
 45 特征：
 46 稳定排序算法
 47 最坏时间复杂度O(n^2)
 48 平均时间复杂度O(n^2)
 49 空间复杂度O(1)
 50 总结：
 51 重复的将遍历元素暂存后，将遍历元素之前的元素较暂存元素大的后移，
 52 将暂存元素插入后移元素最小的前面弥补遍历之前元素后移覆盖引起的元素缺失'''
 53 def insertSort(a):
 54     for i in range(1, len(a)):
 55         e=a[i]; j=i;
 56         while j>0:
 57             if a[j-1] > e:
 58                 a[j] = a[j-1]
 59             else:
 60                 break
 61             j-=1
 62         a[j] = e
 63     return a
 64
 65 '''归并排序
 66 特征：
 67 稳定排序算法
 68 最坏时间复杂度O(nlogn)
 69 平均时间复杂度O(nlogn)
 70 空间复杂度O(n)
 71 总结：
 72 分治法(Divide and Conquer)的典型应用,
 73 递归的将数组分成左右两部分数组，每次分完后将小的放在左边的数组，
 74 大的放在右边的数组，分完后将左右两个数组归并成一个数组'''
 75 class merge(object):
 76     a = None
 77     def __init__(self, a):
 78         self.a = a
 79
 80     def __MergeSort(self, lst):
 81         if len(lst) <= 1:
 82             return lst
 83         num = int(len(lst)/2)
 84         left = self.__MergeSort(lst[:num])
 85         right = self.__MergeSort(lst[num:])
 86         return self.__Merge(left, right)
 87
 88     def __Merge(self, left, right):
 89         R, L=0, 0
 90         result=[]
 91         while L < len(left) and R < len(right):
 92             if left[L] < right[R]:
 93                 result.append(left[L])
 94                 L += 1
 95             else:
 96                 result.append(right[R])
 97                 R += 1
 98         result += right[R:]
 99         result += left[L:]
100         return result
101
102     def sort(self):
103         return self.__MergeSort(self.a)
104
105 '''快速排序
106 特征：
107 不稳定排序算法
108 最坏时间复杂度O(n^2)
109 平均时间复杂度O(nlogn)
110 空间复杂度O(logn)~O(n)
111 注：初始最低位L输入为0, 最高位H输入为数组长度减1即数组末尾的索引值
112 总结：
113 引用分治法对冒泡法的改进，
114 递归的以数组最低位为基数，重复的左右两端相向与基数比较，
115 左边比基数大的与右边比基数小的交换，直到左右相遇，
116 这是一个将最低位元素移动到已排序后数组位置的过程'''
117 def quickSort(a, L, H):
118     i = L; j = H;
119     if i >= j:
120         return a
121     B = a[i]
122     while i < j:
123         while i < j and a[j] >= B:
124             j = j-1
125         a[i] = a[j]
126         while i < j and a[i] <= B:
127             i = i+1
128         a[j] = a[i]
129     a[i] = B
130     a = quickSort(a, L, i-1)
131     a = quickSort(a, j+1, H)
132     return a
133
134 '''统计排序
135 注：由于统计排序需要有已知有序数组做筒，故这里统计后
136 使用python自带的sort生成已知有序数组
137 总结：已知有序数组做筒，统计相同元素数量
138 '''
139 def countSort(a):
140     dtmp = {}
141     for i in a:
142         if i not in dtmp:
143             dtmp[i]=1
144         else:
145             dtmp[i]+=1
146     tmp = list(dtmp.keys())
147     tmp.sort()
148     a=[]
149     for i in tmp:
150         for j in range(dtmp[i]):
151             a.append(i)
152     dtmp = None
153     tmp = None
154     return a
155
156 '''基数排序
157 稳定排序算法
158 注：因为在这里以0-9分别做每位比较后存入的筒，这里输入的数组中应是整数'''
159 def radixSort(a):
160     max = 0
161     for i in a:
162         if i > max:
163             max = i
164     b = len(str(max))
165     for i in range(b):
166         tmp=[[], [], [], [], [], [], [], [], [], []]
167         for j in a:
168             v = str(j)
169             if len(v)-1 < i:
170                 tmp[0].append(j)
171             else:
172                 k = v[len(v)-i-1:len(v)-i]
173                 tmp[int(k)].append(j)
174         index = 0
175         for t in tmp:
176             for tv in t:
177                 a[index] = tv
178                 index+=1
179     return a
180
181 def main():
182     r = [15,28,6,1,5,47,265,19, 8, 255, 166, 78, 41, 8, 16,
183          215,128,26,11,25,147,265,19, 28, 155, 266, 178, 1, 8, 160,
184          153,282,6,12,52,472,652,97, 87, 55, 66, 78, 14, 80, 16]
185     #r = ['c', 'v', 's', 'd', 'e', 'f', 'a', 'k', 'l']
186     print('未排序数组 长度=',len(r),'\n', r)
187     a0 = r.copy()
188     a1 = r.copy()
189     a2 = r.copy()
190     a3 = r.copy()
191     a4 = r.copy()
192     a5 = r.copy()
193     a6 = r.copy()
194     r.sort()
195     print('python中list自带的排序\n', r)
196     print('冒泡排序\n', bubbleSort(a0))
197     print('选择排序\n', selectSort(a1))
198     print('插入排序\n', insertSort(a2))
199     print('归并排序\n', merge(a3).sort())
200     print('快速排序\n', quickSort(a4,0, len(a4)-1))
201     print('统计排序\n', countSort(a5))
202     print('基数排序\n', radixSort(a6))
203
204 if __name__ == '__main__':
205     main()