经典排序的python实现

 具体原理我这里就不解释了，可以查看数据结构课本或者百度百科
 这里只给出相应的代码（很简洁）

 1 __author__ = "WSX"
 class sort:
     def __init__(self,):
         pass

     def merger(self, left , right): # 合并两个有序列表
         i = 0;  j = 0 ; result = []
         while left and right:
             if left[i] <= right[j]:
                 result.append(left.pop(0))
             else:
                 result.append(right.pop(0))
         result += left[:]
         result += right[:]
         return result

     def mergeSort(self, L):  #归并排序
         if len(L) == 1:
             return L
         mid = len(L) // 2
         left = self.mergeSort(L[:mid])
         right = self.mergeSort(L[mid:])
         return self.merger(left, right)

     def insert1(self, L):   #直接插入排序 俩个for实现
         for i in range(1,len(L)):
             temp = L[i]
             for j in range(i-1,-1,-1):
                 if L[i] < L[j]:
                     L[j+1] = L[j]
                 else:
                     j += 1
                     break
             L[j] = temp
         return L

     def insert2(self, L):  #直接插入排序 for 结合 while
         for i in range(1, len(L)):
             temp = L[i]
             j = i-1
             while j >=0 and temp < L[j]:
                 L[j+1] = L[j]
                 j -= 1
             L[j+1] = temp
         return L

     def bubblk(self, L):  #冒泡排序
         for i in range(len(L)-1):
             for j in range(len(L)-i-1):
                 if L[j+1] < L[j]:
                     L[j+1], L[j] = L[j], L[j+1]
         return L

     def quickSort1(self,L):  #快速排序
         if len(L) <= 1:
             return L
         else:
             return self.quickSort1([i for i in L[1:] if i < L[0]]) + [L[0]] + self.quickSort1([j for j in L[1:] if j > L[0]])

     def shellSort(self, L):
         pass

     def selectSort(self, L):  #选择排序
         for i in range(len(L) -1 ):
             index = i
             for j in range(i+1, len(L)):
                 if L[j] < L[index]:
                     index = j
             L[index], L[i] = L[i] ,L[index]
         return L

     def sortHeap(self,L):  #堆排序
         def heap(L, size, root):
             larger = root
             left = 2 * root + 1;
             right = 2 * root + 2
             if left < size and L[left] > L[larger]:
                 larger = left
             if right < size and L[right] > L[larger]:
                 larger = right
             if larger != root:
                 L[larger], L[root] = L[root], L[larger]
                 heap(L, size, larger)

         def bulidHeap(L):  # 初始化堆
             heapsize = len(L)
             for i in range(heapsize // 2, -1, -1):
                 heap(L, heapsize, i)

         bulidHeap(L)
         for i in range(len(L) - 1, -1, -1):
             L[0], L[i] = L[i], L[0]
             heap(L, i, 0)
         return L

 a = sort()
 print(a.sortHeap([25,3,9,7,55,96]))