常见排序算法的python实现

class SortTools():
    
    def __init__(self):
        pass
        
    def bubble_sort_one(self, src_list):
        list_len = len(src_list)
        for i in range(0, list_len-1):
            if src_list[i] < src_list[i+1]:
                tmp = src_list[i+1]
                src_list[i+1] = src_list[i]
                src_list[i] = tmp
        print(src_list)
        return src_list
	# 冒泡排序
    def bubble_sort(self, src_list):
        list_len = len(src_list)
        for i in range(0, list_len):
            src_list[:list_len - i] = self.bubble_sort_one(src_list[:list_len - i])
                
        return src_list
    
    
    def fast_division(self, src_list, left, right):
        base = src_list[left]
        while left < right:
            while left < right and src_list[right] > base:
                right -= 1;
            src_list[left] = src_list[right]
            # print(src_list)
            while left < right and src_list[left] <= base:
                left += 1
            src_list[right] = src_list[left]
            # print(src_list)
        src_list[left] = base
        print(src_list)
        return left
    # 快速排序
    def fast_sort(self, src_list, left, right):
        if left < right:
            base = self.fast_division(src_list, left, right)
            self.fast_sort(src_list, left, base-1)
            self.fast_sort(src_list, base+1, right)
        # print(src_list)
        return src_list
    # 插入排序
    def insert_sort(self, src_list):
        list_len = len(src_list)
        for i in range(1,list_len):
            tmp = src_list[i]
            j = i-1
            while j>=0 and tmp < src_list[j]:
                src_list[j+1] = src_list[j]
                j -= 1
            src_list[j+1] = tmp
            print(src_list)
        return src_list
    # 希尔排序
    def hill_sort(self, src_list):
        list_len = len(src_list)
        gap = list_len / 2
        while gap >= 1:
            for i in range(gap,list_len):
                tmp = src_list[i]
                j = i - gap
                while j>=0 and tmp < src_list[j]:
                    src_list[j+gap] = src_list[j]
                    j -= gap
                src_list[j+gap] = tmp
            print(src_list)
            gap = gap / 2
        return src_list
    # 简单选择排序
    def basic_select_sort(self, src_list):
        list_len = len(src_list)
        for i in range(0, list_len-1):
            min_v = src_list[i]
            pos = i
            for j in range(i+1, list_len):
                if src_list[j] < min_v:
                    min_v = src_list[j]
                    pos = j
            if pos != i:
                src_list[pos] = src_list[i]
                src_list[i] = min_v
            print(src_list)
        
        return src_list
    
    def heap_adjust(self, src_list, parent, list_len):
        tmp = src_list[parent]
        child = 2 * parent + 1
        
        while child < list_len:
            if child + 1 < list_len and src_list[child] < src_list[child + 1]:
                child += 1
            if tmp > src_list[child]:
                break
            src_list[parent] = src_list[child]
            parent = child
            child = 2 * child + 1
        
        src_list[parent] = tmp
    # 堆排序    
    def heap_sort(self, src_list):
        list_len = len(src_list)
        for i in range(0, list_len/2 + 1):
            j = list_len/2 - i
            self.heap_adjust(src_list, j, list_len)
        
        for i in range(1, list_len):
            j = list_len - i
            tmp = src_list[j]
            src_list[j] = src_list[0]
            src_list[0] = tmp
            
            self.heap_adjust(src_list, 0, j)
            
            print(src_list)
        return src_list
    
    
    def merge(self, src_list, low, mid, high):
        i = low
        j = mid + 1
        k = 0
        list_tmp = []
        while i <= mid and j <= high:
            if src_list[i] < src_list[j]:
                list_tmp.append(src_list[i])
                i += 1
            else:
                list_tmp.append(src_list[j])
                j += 1
        while i <= mid:
            list_tmp.append(src_list[i])
            i += 1
        while j <= high:
            list_tmp.append(src_list[j])
            j += 1
            
        for k in range(0, high - low + 1):
            src_list[k+low] = list_tmp[k]
        return src_list
    
    def merge_pass(self, src_list, gap, list_len):
        i = 0
        while i + 2 * gap - 1 < list_len:
            src_list = self.merge(src_list, i, i + gap -1, i + 2 * gap - 1)
            i = i + 2 * gap
        if i + gap < list_len:
            src_list = self.merge(src_list, i, i + gap -1, list_len - 1)
            
        return src_list
    # 归并排序            
    def merge_sort(self, src_list):
        gap = 1
        list_len = len(src_list)
        while gap < list_len:
            src_list = self.merge_pass(src_list, gap, list_len)
            gap *= 2
            print(src_list)
        return src_list
    
if __name__ == "__main__":
    init_list = [4,7,5,3,2,1,5,9,6,8,7]
    print(init_list)
    sort_tool = SortTools()
    print("sort")
    # print(sort_tool.bubble_sort(init_list))
    # print(sort_tool.fast_sort(init_list, 0, len(init_list) - 1))
    # print(sort_tool.insert_sort(src_list=init_list))
    # print(sort_tool.hill_sort(src_list=init_list))
    # print(sort_tool.basic_select_sort(src_list=init_list))
    # print(sort_tool.heap_sort(src_list=init_list))
    print(sort_tool.merge_sort(src_list=init_list))