python实现排序算法

冒泡排序

def maopao(array):
    for i in range(len(array)):
        for j in range(len(array) - i - 1):
            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
    return array

选择排序

def xuanze(array):
    for i, num in enumerate(array):
        min_index = i
        for j in range(i + 1, len(array)):
            if array[min_index] > array[j]:
                min_index = j
        if min_index != i:
            array[i], array[min_index] = array[min_index], array[i]
    return array

插入排序

def charu(array):
    result = []
    for index, num in enumerate(array):
        for i in range(index):
            if result[i] > num:
                result.insert(i, num)
                break
        else:
            result.append(num)
    return result

希尔排序

def shell(array):
    length = len(array) // 2
    while length != 1:
        array = charu_tap(array, length)
        length = length // 2
    else:
        return charu_tap(array, length)

def charu_tap(array, tap):
    result = []
    for index, num in enumerate(array):
        if index // tap >= 1:
            strat = index % tap
            for i in range(strat, index, tap):
                if result[i] > num:
                    result.append(num)
                    result[i], result[index] = result[index], result[i]
                    break
            else:
                result.append(num)
        else:
            result.append(num)
    return result

归并排序

def merge_sort(lst, fx=True):
    if len(lst) <= 1:
        # 当列表元素只有一个的时候，直接返回
        return lst
    mid = len(lst) // 2
    left = lst[:mid]
    right = lst[mid:]
    starttime = time.time()
    left = merge_sort(left, not fx)
    right = merge_sort(right, not fx)

    # 递归的进行排序
    result = []
    while left and right:
        if (left[-1] < right[-1]) == fx:
            result.append(left.pop())
        else:
            result.append(right.pop())
    if left:
        if fx and len(left) == 1:
            result.extend(left)
        else:
            left.reverse()
            result.extend(left)
    if right:
        if fx and len(right) == 1:
            result.extend(right)
        else:
            right.reverse()
            result.extend(right)

    return result
    # 返回排序后的结果

快速排序

class Sort:
	@staticmethod
    def quick_sort(sort_list, fir=None, last=None):
        """
        快速排序

        :param sort_list:
        :param fir:
        :param last:
        :return:
        """
        if fir is None and last is None:
            fir = 0
            last = len(sort_list) - 1

        if fir < last:
            sp = Sort._swap_position(sort_list, fir, last)
            Sort.quick_sort(sort_list, fir, sp - 1)
            Sort.quick_sort(sort_list, sp + 1, last)

	@staticmethod
    def _swap_position(arr, fir, last):
        pv = arr[fir]
        lm = fir + 1
        rm = last
        do = False
        while not do:
            while lm <= rm and arr[lm] <= pv:
                lm = lm + 1
            while arr[rm] >= pv and rm >= lm:
                rm = rm - 1
            if rm < lm:
                do = True
            else:
                temp = arr[lm]
                arr[lm] = arr[rm]
                arr[rm] = temp
        temp = arr[fir]
        arr[fir] = arr[rm]
        arr[rm] = temp
        return rm

效率测试代码

# 生成 10W数据
list_num = [i * random.random() for i in range(100000)]
# 打乱顺序
random.shuffle(list_num)
# 测试代码：归并测试
t5 = timeit.Timer("merge_sort(list_num,False)", "from __main__ import merge_sort,list_num")
# 测试次数 10次
print("test5", t5.timeit(number=10), "milliseconds")