常用的排序算法和Python内置的sorted方法

常用的排序算法和Python内置的sorted方法

一.排序算法

1.选择排序

基本思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推

def select_sort(lst):
    """选择排序"""
    for i in range(len(lst)): # 外层循环,i为从0开始下标
        min_index = i # 假设i为最小值的下标
        for j in range(i + 1, len(lst)):  # 内层循环，j为未排序序列下标
            if lst[j] < lst[min_index]: 
                min_index = j  # 将未排序序列中找到的最小值赋给min_index
        lst[i], lst[min_index] = lst[min_index], lst[i] # 交换值
    return lst

2.冒泡排序

基本思想: 让一个数字和它相邻的下一个数字比较，如果前一个数字大于后一个数字，交换两个变量的值

def bubble_sort(lst):
    """冒泡排序"""
    for j in range(0, len(lst) - 1): # 外层循环，这个循环负责冒泡排序进行的次数
        for i in range(0, len(lst) - j - 1): # 内层循环，i为列表下标
            if lst[i] > lst[i + 1]:
                lst[i], lst[i + 1] = lst[i + 1], lst[i] # 如果if成立，交换值
    return lst

3.插入排序

基本思想: ①将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列

​ ②从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置

def insert_sort(lst):
    """插入排序"""
    # 遍历列表中的所有元素,其中0号索引元素默认已排序,因此从1开始
    for i in range(1, len(lst)):
        # 将该元素(j+1)与已排序好的元素(j)从右到左依次比较,如果比该元素(j)小,则交换
        # range(i-1,-1,-1)
        for j in range(i - 1, -1, -1): 
            if lst[j] > lst[j + 1]:  
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
    return lst

4. 希尔排序

希尔排序也算插入排序的一种，比起直接插入排序来说，更高效

基本思想：①先将整个待排元素序列分割成若干个子序列，分别进行插入排序

​ ②依次缩减增量再进行排序，直至增量为1

def shell_sort(lst):
    """希尔排序"""
    step = int(len(lst) / 2)   # 规定步长
    while step > 0:  # 判断是不是最后一次排序
        for index in range(0, len(lst)): 
            if index + step < len(lst): 
                temp = lst[index]
                if temp > lst[index + step]: # 比较步长前后元素大小
                    lst[index], lst[index + step] = lst[index + step], lst[index]
        print(lst)
        step = int(step / 2) # 步长减半
    return lst

print(shell_sort([9, 1, 2, 5, 7, 4, 8, 6, 3, 5]))

#[4, 1, 2, 3, 5, 9, 8, 6, 5, 7]
#[2, 1, 4, 3, 5, 6, 5, 7, 8, 9]
#[1, 2, 3, 4, 5, 5, 6, 7, 8, 9]
#[1, 2, 3, 4, 5, 5, 6, 7, 8, 9]

二.Python内置的sorted方法

1. sorted() 和 list.sort() 方法比较

主要区别在于列表的sort方法是对已经存在的列表进行操作，而python内置函数sorted返回的是一个新的list。

lst1 = [1, 3, 7, 2, 6, 4, 9, 5]

print(lst1.sort())
print(lst1)
#None
#[1, 2, 3, 4, 5, 6, 7, 9]

lst2 = [2, 5, 6, 7, 3, 1, 4]
print(sorted(lst2))
print(lst2)

#[1, 2, 3, 4, 5, 6, 7]
#[2, 5, 6, 7, 3, 1, 4]

也就是说list.sort 方法会就地排序列表，不会把原列表复制一份。这也是这个方法的返回值是None的原因，提醒你本方法不会新建一个列表。在这种情况下返回None其实是Python的一个惯例，如果一个函数或者方法对对象进行的是就地改动，那它就会返回None，好让调用者知道传入的参数发生了变动，而且并未产生新的对象。

而sorted它会新建一个列表作为返回值。这个方法可以接受任何形式的可迭代对象作为参数，甚至包括不可变序列或生成器，最后都会返回一个列表。

2.sorted和list.sort()中的两个参数

sorted(__iterable,key,reverse)

list.sort(self,key,reverse)

①reverse

如果被设定为 True，被排序的序列里的元素会以降序输出，这个参数的默认值是 False。

②key

一个只有一个参数的函数，这个函数会被用在序列里的每一个元素上，所产生的结果将是排序算法依赖的对比关键字，这个参数的默认值是恒等函数，也就是默认用元素自己的值来排序。key这个参数的存在帮助我们实现复杂排序要求。比如说，在对列表中一些字符串排序时，可以用key=str.lower来实现忽略大小写的排序，或者是用key=len进行基于字符串长度的排序,当然key的参数也可以是个匿名函数。

lst = [('e', 4), ('o', 2), ('!', 5), ('v', 3), ('l', 1)]
print(sorted(lst, key=lambda x: x[1]))

# [('l', 1), ('o', 2), ('v', 3), ('e', 4), ('!', 5)]

d = {'jack': 25, 'tom': 22, 'rose': 32, 'jason': 19}
print(sorted(d.items(), key=lambda item: item[1]))

# [('jason', 19), ('tom', 22), ('jack', 25), ('rose', 32)]