一些排序算法的Python实现

 '''
 Created on 2016/12/16
 Created by freeol.cn
 一些排序算法的Python实现
 @author: 拽拽绅士
 '''

 '''值交换'''
 def swap(m, n):
     c = m; m = n; n = c;
     return m, n

 '''冒泡排序
 特征：
 稳定排序算法
 最坏时间复杂度O(n^2)
 平均时间复杂度O(n^2)
 空间复杂度O(1)
 总结：重复的相邻元素进行比较交换，越大的元素
 会经由交换慢慢“浮”到数列的顶端'''
 def bubbleSort(a):
     for i in range(0, len(a)):
         for j in range(0, len(a)-i-1):
             if a[j] > a[j+1]:
                 a[j], a[j+1] = swap(a[j],a[j+1])
     return a

 '''选择排序
 特征：
 不稳定排序算法
 最坏时间复杂度O(n^2)
 平均时间复杂度O(n^2)
 空间复杂度O(1)
 总结：重复的选择后面最小的与遍历到的位置交换'''
 def selectSort(a):
     for i in range(0, len(a)-1):
         min = i
         for j in range(i+1, len(a)):
             if a[j] < a[min]:
                 min = j
         a[i], a[min] = swap(a[i], a[min])
     return a

 '''插入排序
 特征：
 稳定排序算法
 最坏时间复杂度O(n^2)
 平均时间复杂度O(n^2)
 空间复杂度O(1)
 总结：
 重复的将遍历元素暂存后，将遍历元素之前的元素较暂存元素大的后移，
 将暂存元素插入后移元素最小的前面弥补遍历之前元素后移覆盖引起的元素缺失'''
 def insertSort(a):
     for i in range(1, len(a)):
         e=a[i]; j=i;
         while j>0:
             if a[j-1] > e:
                 a[j] = a[j-1]
             else:
                 break
             j-=1
         a[j] = e
     return a

 '''归并排序
 特征：
 稳定排序算法
 最坏时间复杂度O(nlogn)
 平均时间复杂度O(nlogn)
 空间复杂度O(n)
 总结：
 分治法(Divide and Conquer)的典型应用,
 递归的将数组分成左右两部分数组，每次分完后将小的放在左边的数组，
 大的放在右边的数组，分完后将左右两个数组归并成一个数组'''
 class merge(object):
     a = None
     def __init__(self, a):
         self.a = a

     def __MergeSort(self, lst):
         if len(lst) <= 1:
             return lst
         num = int(len(lst)/2)
         left = self.__MergeSort(lst[:num])
         right = self.__MergeSort(lst[num:])
         return self.__Merge(left, right)

     def __Merge(self, left, right):
         R, L=0, 0
         result=[]
         while L < len(left) and R < len(right):
             if left[L] < right[R]:
                 result.append(left[L])
                 L += 1
             else:
                 result.append(right[R])
                 R += 1
         result += right[R:]
         result += left[L:]
         return result

     def sort(self):
         return self.__MergeSort(self.a)

 '''快速排序
 特征：
 不稳定排序算法
 最坏时间复杂度O(n^2)
 平均时间复杂度O(nlogn)
 空间复杂度O(logn)~O(n)
 注：初始最低位L输入为0, 最高位H输入为数组长度减1即数组末尾的索引值
 总结：
 引用分治法对冒泡法的改进，
 递归的以数组最低位为基数，重复的左右两端相向与基数比较，
 左边比基数大的与右边比基数小的交换，直到左右相遇，
 这是一个将最低位元素移动到已排序后数组位置的过程'''
 def quickSort(a, L, H):
     i = L; j = H;
     if i >= j:
         return a
     B = a[i]
     while i < j:
         while i < j and a[j] >= B:
             j = j-1
         a[i] = a[j]
         while i < j and a[i] <= B:
             i = i+1
         a[j] = a[i]
     a[i] = B
     a = quickSort(a, L, i-1)
     a = quickSort(a, j+1, H)
     return a

 '''统计排序
 注：由于统计排序需要有已知有序数组做筒，故这里统计后
 使用python自带的sort生成已知有序数组
 总结：已知有序数组做筒，统计相同元素数量
 '''
 def countSort(a):
     dtmp = {}
     for i in a:
         if i not in dtmp:
             dtmp[i]=1
         else:
             dtmp[i]+=1
     tmp = list(dtmp.keys())
     tmp.sort()
     a=[]
     for i in tmp:
         for j in range(dtmp[i]):
             a.append(i)
     dtmp = None
     tmp = None
     return a

 '''基数排序
 稳定排序算法
 注：因为在这里以0-9分别做每位比较后存入的筒，这里输入的数组中应是整数'''
 def radixSort(a):
     max = 0
     for i in a:
         if i > max:
             max = i
     b = len(str(max))
     for i in range(b):
         tmp=[[], [], [], [], [], [], [], [], [], []]
         for j in a:
             v = str(j)
             if len(v)-1 < i:
                 tmp[0].append(j)
             else:
                 k = v[len(v)-i-1:len(v)-i]
                 tmp[int(k)].append(j)
         index = 0
         for t in tmp:
             for tv in t:
                 a[index] = tv
                 index+=1
     return a

 def main():
     r = [15,28,6,1,5,47,265,19, 8, 255, 166, 78, 41, 8, 16,
          215,128,26,11,25,147,265,19, 28, 155, 266, 178, 1, 8, 160,
          153,282,6,12,52,472,652,97, 87, 55, 66, 78, 14, 80, 16]
     #r = ['c', 'v', 's', 'd', 'e', 'f', 'a', 'k', 'l']
     print('未排序数组 长度=',len(r),'\n', r)
     a0 = r.copy()
     a1 = r.copy()
     a2 = r.copy()
     a3 = r.copy()
     a4 = r.copy()
     a5 = r.copy()
     a6 = r.copy()
     r.sort()
     print('python中list自带的排序\n', r)
     print('冒泡排序\n', bubbleSort(a0))
     print('选择排序\n', selectSort(a1))
     print('插入排序\n', insertSort(a2))
     print('归并排序\n', merge(a3).sort())
     print('快速排序\n', quickSort(a4,0, len(a4)-1))
     print('统计排序\n', countSort(a5))
     print('基数排序\n', radixSort(a6))

 if __name__ == '__main__':
     main()