第三课 排序算法LowB三人组

python数据结构与算法基础 第三课

tags:

• python
• 路飞学院

categories:

• python
• 排序算法
• LowB 三人组
• 冒泡排序
• 选择排序
• 插入排序

第一节 什么是列表排序

1. 列表排序介绍

1. 排序:将一组“无序”的记录序列调整为“有序”的记录序列
2. 列表排序:将无序列表变为有序列表。
3. 输入:列表 输出:有序列表
4. 升序与降序
5. 内置排序函数: sort()
6. 榜单、红黑榜、使用网站评率等
7. 常见的排序算法如下

排序LowB三人组	排序NB三人组	其他排序
冒泡排序	快速排序	希尔排序
选择排序	堆排序	计数排序
插入排序	归并排序	基数排序

第二节 冒泡排序

1. 冒泡排序原理和实现

1. 列表每两个相邻的数，如果前面比后面大，则交换这两个数。
2. 一趟排序完成后，则无序区减少一个数，有序区增加一个数。
3. 代码关键点:趟、无序区范围

    #!/usr/bin/env python3
    
    # 冒泡排序
    def bubble_sort(li):
        # 整个列表的循环是n-1趟
        # i=0 第一趟 无需区 len(li)-1
        # i=1 第二趟 无需区 len(li)-1-1
        # i=n-1 第n-1趟 无需区 len(li)-1-(n-1)
        # 第i趟 无序区的长度为len(li)-1-i
        for i in range(len(li)-1):
            for k in range(len(li)-1-i):
                if li[k] > li[k+1]:
                    li[k], li[k+1] = li[k+1], li[k]
    
    
    import random
    list = random.sample([i for i in range(1000)], 20)
    print(list)
    bubble_sort(list)
    print(list)

2. 冒泡排序改进和分析

1. 时间复杂度: O(n^2)
2. 如果一趟中列表排序中没有发生任何交换,我们可以认为列表已经是有序的了
3. 可以加个标志位

    #!/usr/bin/env python3
    
    # 冒泡排序改进
    def bubble_sort_impro(li):
        for i in range(len(li)-1):
            exchange = False
            for k in range(len(li)-1-i):
                if li[k] > li[k+1]:
                    li[k], li[k+1] = li[k+1], li[k]
                    exchange = True
            if not exchange:
                return
    
    import random
    list1= [random.randint(0,1000) for i in range(20)]
    print(list1)
    bubble_sort_impro(list1)
    print(list1)

第三节 选择排序

1. 选择排序原理和实现

1. 每次从列表中选出最小的数放到一个新列表中
2. 时间复杂度: O(n^2)

    #!/usr/bin/env python3
    # 简单版选择排序
    def select_sort(li):
        li_new = []
        for i in range(len(li)):
            # 有重复的也没关系，会从左边找
            # min是0(n) remove是一个O(n)
            min_val = min(li)
            li_new.append(min_val)
            li.remove(min_val)
        return li_new

    import random
    list = random.sample([i for i in range(1000)], 20)
    print(list)
    li_new = select_sort(list)
    print(li_new)

2. 选择排序改进和分析

1. 上述选择排序多占用了一份内存。空间复杂度变成2*n。
2. 这不是必要的可以进行改进，避免掉
3. 我把选择的出的数放在最前面的位置就可以了。最前面的数和选出的数交换
4. 算法关键点:有序区和无序区、无序区最小数的位置
5. 时间复杂度: O(n^2)

    #!/usr/bin/env python3
   # 改进版选择排序
    def select_sort_impro(li):
        for i in range(len(li)-1):
            # 假设最小值是无序区的第一个位置
            min_loc = i
            # 可以偷次懒 i 不需要和自己比拉
            for j in range(i+1, len(li)):
                if li[j] < li[min_loc]:
                    min_loc = j
            li[i], li[min_loc] = li[min_loc], li[i]

    import random

    list1= [random.randint(0,1000) for i in range(20)]
    print(list1)
    select_sort_impro(list1)
    print(list1)

第四节 插入排序

1. 插入排序原理和实现

1. 初始时手里(有序区)只有- -张牌
2. 每次(从无序区)摸一-张牌，插入到手里已有牌的正确位置

    #!/usr/bin/env python3
   # 插入排序
    def insert_sort(li):
        for i in range(1, len(li)): # i表示摸到的牌
            temp = li[i]
            j = i - 1 # j表示有序区的最后一张牌(手里的牌)
            while j >= 0 and li[j] > temp:
                li[j + 1] = li[j]
                j -= 1
            li[j + 1] = temp


    import random
    list = random.sample([i for i in range(1000)], 20)
    print(list)
    insert_sort(list)