基础算法（一）（待补充）

内容概要

　　一、冒泡算法、代码实现、复杂度计算

　　二、选择排序、代码实现、复杂度计算

　　三、插入排序、代码实现、复杂度计算

 

1、冒泡算法

　　冒泡算法就是将一组数据的前两个数进行比较，将较大的一个数往后移动，再比较紧接着的两个数的大小，直到找到本次遍历中最大的一个数

　　以此类推，直到排序完成

 

　　冒泡算法图解

　　　　**待补充**

 

　　冒泡算法代码实现

import random

def bubble_sort(li):
    end = len(li) - 1
    for i in range(end):  # i层循环每执行一次，就有一个最大值确定，有序区数加一
        for j in range(end - i):  # 遍历无序区的数，找到最大的值，无序区数减一
            if li[j] > li[j+1]:  # 如果前一个数大于紧接着的下一个数，则将较大的一个数后移
                li[j], li[j+1] = li[j+1], li[j]
                # print(li)　　

li = [random.randrange(1,1001) for i in range(1000)]

bubble_sort(li)
print(li)

 

　　冒泡算法优化

def bubble_sort(li):
    end = len(li) - 1
    for i in range(end):
        exchange = False  # 加入exchange变量，当遍历一次无序区时，
没有发生交换，说明数据已经排序好
        for j in range(end - i):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                exchange = True

        if not exchange:
            break
        # print(li)

 

　　冒泡算法进行了两层嵌套的循环

　　　　且外层循环次数与i有关，内层循环次数也与i有关

　　　　所以冒泡算法的复杂度为O(n**2)

 

2、选择排序

　　选择排序就是不断的遍历一组数据，找到剩下数据中最小的一个，依次将最小的数取出进行排序

 

　　选择排序图解

　　　　**待补充**

 

　　　　-简单版本的选择排序

　　　　　　将取到的数据存放在另外一个列表中

def simple_select_sort(li):
    end = len(li) - 1
    new_li = []  # 用于存放每次遍历的最小值的新列表
    for i in range(end + 1):
        '''
            min_val = li[0]:
            for j in range(1,end + 1 - i):
                if li[j] < min_val:
                    min_val = li[j]
        '''
        min_val = min(li)  # 找到本次遍历的最小值
        new_li.append(min_val)  # 将最小值添加到列表末尾
        li.remove(min_val)  # 删除原本例表中的最小值，避免对下一次遍历产生影响
    return new_li

 

　　　　-优化版本的选择排序

　　　　　　不使用一个新的列表

def select_sort(li):
    end = len(li) - 1
    for i in range(end):  # 每次遍历找到一个最小值，并添加到有序区最后
        min_index = i  # min_index初始化为无序区的第一个数的下标
        for j in range(i + 1, end + 1):
            if li[j] < li[min_index]:  # 遍历无序区中其它数，如果有min_index对应的数还小的数存在，将min_index指向那个数的索引
                min_index = j
        li[i], li[min_index] = li[min_index], li[i]  # 交换无序区第一个数和找到的最小值——min_index指向的值

　　　　选择排序的时间复杂度计算

　　　　　　选择排序的时间复杂度也是O(n**2)

　　　　　　注意的是，简单版本的选择排序的时间复杂度也是O(n**2)，而不是O(2n**2)

 

3、插入排序

　　插入排序就是依次从一组数据的无序区中取出一个数，将这个数插入到有序区中合适的位置

 

　　插入排序图解

　　　　**待补充**

 

　　插入排序代码实现

import random

def insert_sort(li):
    end = len(li) - 1
    for i in range(1, end + 1):  # i为无序区的第一个数
        tmp = li[i]  # 将无序区第一个数存起来
        for j in range(i-1, -1, -1):  # j为有序区最后一个数，j从右往左递减，比较li[j]和tmp的大小，找到tmp合适的位置
            if li[j] > tmp:  # li[j]大于tmp，将li[j]的值往后移
                li[j+1] = li[j]
            else:  # li[j]小于tmp，说明此时tmp应该在li[j]的右边
                li[j+1] = tmp
                break
        else:  # 正常跳出循环，说明tmp是无序区最小的数，将它放到开头位置
            li[0] = tmp


li = [i for i in range(1000)]
print(li)
random.shuffle(li)
print(li)
insert_sort(li)
print(li)

　　　　插入排序的时间复杂度计算

　　　　　　插入排序有两层循环，且内外层循环次数均与i有关，所以插入排序的时间复杂度也是O(n**2)

 

***待补充***