几种排序算法的Python实现

为了找工作需要，很多都是要手撸排序算法的，今天就手撸了几个经常让撸的排序算法，贴个代码占个坑。

#coding=utf-8
import random
import time
# 练习排序算法专用程序，手撸各种排序



class sort:

    def compare(self,a,b,axis = 0):
        #axis = 0表示降序
        if axis == 0:
            resu =  True if a>b else  False
        else:
            resu = True if a<b else  False
        return resu

    def bubble_sort(self, numbers, axis=0):
        length = len(numbers)
        num = numbers.copy()
        for i in range(length-1):
            flag = True
            for j in range(length-1-i):
                if self.compare(num[j],num[j+1],axis):
                    tmp = num[j]
                    num[j] = num[j+1]
                    num[j+1] = tmp
                    flag = False
            if flag: break
        return num

    def quicksort(self, num, l,r, axis=0):
        start = l
        end = r
        if l<r:
            tmp = num[l]
            while l < r:
                while l < r and self.compare(tmp, num[r], axis): r -= 1
                num[l] = num[r]
                while l < r and self.compare(num[l], tmp, axis): l += 1
                num[r] = num[l]
            num[l] = tmp
            self.quicksort(num,start, l-1,axis)
            self.quicksort(num,l+1,end,axis)
        return num

    def merge_sort(self, num,l,r,axis=0):
        if l == r: return [num[l]]
        mid = (l+r) // 2
        left = self.merge_sort(num,l,mid,axis)
        right = self.merge_sort(num,mid+1,r,axis)
        resu = []
        p1 = 0
        p2 = 0
        while p1<len(left) and p2<len(right):
            if self.compare(left[p1],right[p2],axis):
                resu.append(left[p1])
                p1 += 1
            else:
                resu.append(right[p2])
                p2 += 1
        resu += left[p1:]
        resu += right[p2:]
        return resu

    def make_heap(self, num, p, axis=0):
        maxlen = len(num)
        lef = 2*p+1
        rig = 2*p+2
        large = p
        if lef < maxlen and self.compare(num[large], num[lef], axis): large = lef
        if rig < maxlen and self.compare(num[large], num[rig], axis): large = rig
        if large != p:
            tmp = num[large]
            num[large] = num[p]
            num[p] = tmp
            self.make_heap(num, large, axis)


    def heap_sort(self, num, axis = 0):
        tmpnum = num.copy()
        le = len(tmpnum)
        for i in range((le-2)//2,-1,-1):
            self.make_heap(tmpnum,i,axis)

        resu = []
        for i in range(len(tmpnum)):
            self.make_heap(tmpnum,0,axis)
            resu.append(tmpnum[0])
            tmpnum[0] = tmpnum[len(tmpnum)-1]
            del tmpnum[len(tmpnum)-1]

        return resu


if __name__ == '__main__':
    so = sort()
    li = [i for i in range(1000)]
    random.shuffle(li)
    start = time.time()
    bli = so.merge_sort(li,0,len(li)-1,0)
    end = time.time()
    print('the waste time of merge_sort', end - start)

    start = time.time()
    bli = so.quicksort(li, 0, len(li) - 1, 0)
    end = time.time()
    print('the waste time of quick_sort', end - start)

    start = time.time()
    bli = so.heap_sort(li, 0)
    end = time.time()
    print('the waste time of heap_sort', end - start)

    print(bli)