“啃”基础算法-排序算法: 选择排序

排序算法复杂度和稳定性速查表

又慢又不稳定!!!

版本一(Cost time:6.77)

import time
'''
每次遍历数组，选择最小值添加到新列表，并在原列表中删除本次遍历最小值
'''
def select_sort1(alist):
    new_list = []
    while len(alist) > 0:  # 遍历到最后一个数
        min_value = alist[0]  # 每次设数组第一个数为最小值
        for i in range(1, len(alist)):  # 将数组剩下的值与最小值对比
            if alist[i] < min_value:  # 如果alist[i]小于最小值
                min_value = alist[i]  # 将最小值变为alist[i]  Cost time:0.129058837890625
        new_list.append(alist.pop(alist.index(min_value)))  # 选择最小值加入新列表， 并在原列表删除该值
    return new_list


if __name__ == '__main__':
    time_list = []
    start = time.time()
    for j in range(10):
        for i in range(100000):
            lst = [6, 3, 5, 2, 7, 8, 9, 0, 1, 4]
            #new_lst = select_sort_double(lst)
            new_lst = select_sort1(lst)
        end1 = time.time()
        cost1 = end1 - start
        time_list.append(cost1)

    print(new_lst)
    print('Cost time:{0}'.format(np.mean(time_list)))

版本二:减少了交换数值所用的时间, 一次遍历之交换一次数值(Cost time:6.58)

def select_sort(alist):
    new_list = []
    while len(alist) > 0:
        min_value = alist[0]
        min_value_index = 0 # 最小值的索引
        for i in range(1, len(alist)):
            if alist[i] < alist[min_value_index]:
                min_value_index = i # 改变最小索引
        new_list.append(alist.pop(min_value_index))
    return new_list

版本三:同时查找最大值和最小值(Cost time:6.14)

def select_sort_double(alist):
    min_list = []
    max_list = []  # 注意这里不要使用连等 min_list = max_list = [], 对于列表数据类型, 连等是两个变量指向同一个内存空间, 会发生连带效应
    while len(alist) > 1:  # 需要两次pop（）, 多以至少要保证数组里面有2个数
        min_value_index = 0
        max_value_index = 0
        for i in range(1, len(alist)):
            if alist[i] < alist[min_value_index]:  # 注意在选择最小值的时候要使用<号， 不能使用<=， 保证算法的稳定性 
                min_value_index = i
            elif alist[i] >= alist[max_value_index]:  # 注意在选择最大值的时候使用>=，保证算法稳定性
                max_value_index = i
        min_value, max_value = alist[min_value_index], alist[max_value_index]
        min_list.append(min_value)
        max_list.insert(0, max_value)
        alist.pop(alist.index(min_value))
        alist.pop(alist.index(max_value))
    new_list = min_list + alist + max_list  # 当排列的数组是偶数位的时候， alist最后为空值；当其为奇数时， alist剩余一个值
    return new_list

补充: 选择排序本身就是不稳定的, 空间复杂度为O(1), 但是我这里使空间复杂度变成O(n)了, 使选择排序保持了稳定性(个人理解, 欢迎批评指正, 不要误导大家).
同时抛出一个问题, 如果不借助辅助数组, 能否实现“同时找到最大值最小值?”