python排序算法之选择、冒泡、插入算法

1.选择排序
给定一个列表,一趟遍历记录最小的数，放到第一个位置，再一趟遍历记录剩余列表中最小的数，继续放置……
   1.每趟选出一个最小的，得到其索引，然后把该值和该趟的起始值作交换
   该趟最小值在确定的位置，每趟比上一趟比较的数据少一个，数据从前减少
   2.每趟的起始值编号比上一趟的起始值多一，起始编号最大到倒数第二个
   3.直到倒数第二个与倒数第一个比较结束后，程序结束，共进行n-1趟

lwst = [4,3,5,2,1,0,8]

def choose_sort(list):
	i = 0
	while i <len(lwst) - 1:
		min = i
		j = i + 1
		while j <len(lwst):
			if lwst[j] < lwst[min]:
				min = j  # 找到最小值的编号
			j += 1
		if min != i:
			lwst[min],lwst[i] = lwst[i],lwst[min]  # 将起始值与最小编号值交换
		i += 1

choose_sort(lwst)
print(lwst)  # [0, 1, 2, 3, 4, 5, 8]

def choose_sort(list):
    for i in range(len(list)):
        min = i
        for j in range (i+1 ,len(list)):
            if list[j] < list[min]:
                min = j
        if min != i:
            list[i],list[min] = list[min],list[i]

直接选择排序时间复杂度 O(n^2)

2.冒泡排序
       给定一个列表，列表每两个相邻的数，如果前边的比后边的大，那么交换这两个数！
       1.每趟挑出一个最大的值，每趟结束后会有一个数据在确定的位置，即该趟最后一位
       2.每趟数据都会减少一个，数据从后减少
       2.首先将第二个与第一个数据进行比较，直到倒数第一个与倒数第二个比较，程序结束，共进行n-1趟

#  添加装饰器，计算排序所花费的时间


def cal_time(func):
    def wrapper(*args,**kwargs):
        t1 = time.time()
        result = func(*args, **kwargs)
        t2 = time.time()
        print("%s running time: %s secs." %(func.__name__,t2 - t1))
        return result
    return wrapper

@cal_time
def bubble_sort(list):
	n = len(list)
	while n > 1:
		exchange = False  # 添加 是否交换标记
		i = 1
		while i < n:
			if list[i] < list[i-1]:
				list[i],list[i-1] = list[i-1],list[i]  # 直接交换数据
				exchange = True  # 代表该趟发生交换
			i += 1
		if not exchange:  # 若该趟未发生交换，则表明数据已经有序，停止排序
			break
		n -= 1
bubble_sort(lwst)
print(lwst)

def bubble_sort(list):
    for i in range(len(list) - 1):
        swap = False
        for j in range(len(list) - 1 - i):
            if list[j] > list[j+1]:
                list[j],list[j+1] = list[j+1],list[j]
                swap = True
        if not swap:
            return

创建无序的列表序列，可以通过random模块的shuffle方法

import random
data = list(range(1000)
random.shuffle(data)

冒泡时间复杂度 O(n^2) , 最好情况O(n)

3.插入排序
       给定一个列表，列表被分为有序区和无序区两个部分，最初有序区只有一个元素，每次从无序区选择一个元素，插入到有序区的位置，直到无序区变空
       1.在最终顺序确定前无法确定数据的位置
       2.先将第一趟第一个值作为其实值，且是最小值
       3.每趟一个新的起始值,先将这个起始值保存在一个变量里
       4.起始值与其前一个数据比较若不交换则本趟结束，开始下一趟
       若发生交换，则再继续向前比较，直到本趟结束
       5.直到最后一个数据参与比较，程序结束，共进行n-1趟

def insert_sort(list):
	i = 1
	while i < len(list):
		j = i-1
		insert = list[i]  # 保存已有数据
		while j >= 0:
			if list[j] > insert:
				list[j+1] = list[j]  # 将大数据后移一位
				j -= 1
			else:
				break
		list[j+1] = insert  # 将已有数据放入空位
		i += 1
insert_sort(lwst)
print(lwst)

def insert_sort(list):
    for i in range(1,len(list) ):
        item = list[i]
        j = i -1
        while j >= 0 and item < list[j]:
            list[j+1] = list[j]
            j -= 1
        list[j+1] = item

插入排序时间复杂度 O(n^2)

python排序算法 之 选择、冒泡、插入算法

猜你喜欢

python排序算法之选择、冒泡、插入算法