经典排序的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]))