Python - 排序( 插入, 冒泡, 快速, 二分 )
插入排序
算法分析
两次循环, 大循环对队列中的每一个元素拿出来作为小循环的裁定对象
小循环对堆当前循环对象在有序队列中寻找插入的位置
性能参数
空间复杂度 O(1)
时间复杂度 O(n^2)
详细代码解读
import random def func(l): # 外层循环: 对应遍历所有的无序数据 for i in range(1, len(l)): # 备份 取出数据 temp = l[i] # 记录取出来的下标值 pos = i # 内层循环: 对应从后往前扫描所有有序数据 """ i - 1 > 从最后一个有序数据开始, 即无序数据前一位 -1 > 扫描到下标 0 为止, 要包括第一个, 因此设置 -1 往后推一位 -1 > 从后往前扫描 """ for j in range(i - 1, -1, -1): # 若有序数据 大于 取出数据 if l[j] > temp: # 有序数据后移 l[j + 1] = l[j] # 更新数据的插入位置 pos = j # 对应所有有序数据比取出数据大的情况 # 若有序数据 小于/等于 取出数据 else: pos = j + 1 break # 在指定位置插入数据 l[pos] = temp if __name__ == '__main__': l = list(range(1, 13)) random.shuffle(l) func(l) print(l)
简单实例
import random def foo(l): for i in range(1, len(l)): temp = l[i] pos = i for j in range(i - 1, -1, -1): if temp < l[j]: l[j + 1] = l[j] pos = j else: pos = j + 1 break l[pos] = temp return l if __name__ == '__main__': l = list(range(13)) random.shuffle(l) print(l) # [12, 0, 4, 5, 6, 2, 11, 10, 8, 7, 3, 1, 9] print(foo(l)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
冒泡排序
算法分析
两两比较, 每次比较出一个未排序队列的最大值,让只在队列右侧排列
两次循环, 大循环每次输出一个当前最大值.
小循环进行具体的数值比对
性能参数
空间复杂度 O(1)
时间复杂度 O(n^2)
详细代码
""" 入学后, 第一次上体育课, 体育老师要求大家排队, 按照身高从低到高排队 获取全班 10 名同学的身高 """ """ 外层循环 大循环控制总循环次数 内层循环 小循环控制如歌得出这个最大值 计算大小, 然后彼此交换 """ import random """ 基础版 """ def func(l): # 外层循环: 走访数据的次数 for i in range(len(l) - 1): # 内层循环: 每次走访数据时, 相邻对比次数 for j in range(len(l) - i - 1): # 要求从低到高 # 如次序有误就交换 if l[j] > l[j + 1]: l[j], l[j + 1] = l[j + 1], l[j] # 遍历次数 print("走访次数:", i + 1) """ 升级版 """ def foo(l): # 外层循环: 走访数据的次数 for i in range(len(l) - 1): # 设置是否交换标志位 flag = False # 内层循环: 每次走访数据时, 相邻对比次数 for j in range(len(l) - i - 1): # 要求从低到高 # 如次序有误就交换 if l[j] > l[j + 1]: l[j], l[j + 1] = l[j + 1], l[j] # 发生了数据交换 flag = True # 如果未发生交换数据, 则说明后续数据均有序 if flag == False: break # 跳出数据走访 # 遍历次数 print("走访次数:", i + 1) if __name__ == '__main__': l = list(range(1, 11)) random.shuffle(l) print("排序前:", l) # func(l) foo(l) print("排序后:", l)
简单代码
import random def foo(l): for i in range(len(l) - 1): for j in range(len(l) - i - 1): if l[j] > l[j + 1] and j != len(l): l[j], l[j + 1] = l[j + 1], l[j] return l if __name__ == '__main__': l = list(range(13)) random.shuffle(l) print(l) # [2, 3, 0, 7, 8, 11, 10, 6, 4, 5, 12, 1, 9] print(foo(l)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
升级版代码
import random def foo(l): for i in range(len(l) - 1): flag = 1 for j in range(len(l) - i - 1): if l[j] > l[j + 1] and j != len(l): l[j], l[j + 1] = l[j + 1], l[j] flag = 0 if flag: break return l if __name__ == '__main__': l = list(range(13)) random.shuffle(l) print(l) # [0, 9, 1, 3, 8, 12, 6, 5, 2, 7, 10, 11, 4] print(foo(l)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
快速排序
算法分析
首先任意取一个元素作为关键数据 ( 通常取首元素
然后将所有比他小的数据源放在其前面, 所有比它大的放在他后面
通过一次排序将要排序的数据分为独立的两部分
然后按照该方法再递归对两部分数据进行快速排序
性能参数
时间复杂度 O(nlogn)
空间复杂度 O(logn)
稳定性 不稳定
详细代码
# 快速排序 import random def quick(l): # 递归退出条件 # 仅剩一个元素无需继续分组 if len(l) < 2: return l # 设置关键数据 a = l[0] # 找出所有比 a 大的数据 big = [x for x in l if x > a] # 找出所有比 a 小的数据 small = [x for x in l if x < a] # 找出所有与 a 相等的数据 same = [x for x in l if x == a] # 拼接数据排序的结果 return quick(small) + same + quick(big) if __name__ == '__main__': l = list(range(1, 25)) random.shuffle(l) l = quick(l) print(l)
二分查找
算法分析
只能对有序队列进行查找, 利用和中间值进行对比, 然后基于判断将队列丢弃一半的方式
性能参数
时间复杂度 O(log2 n)
空间复杂度 O(1)
详细代码
""" 1. 切分成两部分,取中间值来判断 2. 如何定义下一次的范围: 大于中间值, 在左侧找 小于中间值, 在右侧找 3. 查找失败情况: 中间值 小于左端 或者 中间值 大于 右端 """ """ 扑克牌 只取 黑桃 13 张, 用 1-13 表示, 将牌从小到大排序, 反面向上排成一排, 找到黑桃 6 的位置 """ """ l 原始数据 k 待查找数据 left 首元素下标值 right 尾元素下标值 """ """ 递归方式实现 """ def func(l, k, left, right): # 递归退出条件 if left > right: # 查找结束 return -1 # 获取中间元素对应下标值 middle = (left + right) // 2 # 对比中间元素 和 查找元素 if l[middle] == k: return middle elif l[middle] > k: # 中间值 大于 查找值 # 查找范围是 中分后的 左边部分 # 左侧下标值不变, 右侧下标值变为 middle 前一位 right = middle - 1 return func(l, k, left, right) else: # 中间值 小于 查找值 # 查找范围是 中分后的 右边部分 # 左侧下标值变为 middle 后一位, 右侧下标值不变 left = middle + 1 return func(l, k, left, right) """ 循环方式实现 """ def foo(l, k): left = 0 right = len(l) - 1 while left <= right: mid = (left + right) // 2 if l[mid] > k: right = mid - 1 elif l[mid] < k: left = mid + 1 elif l[mid] == k: return midreturn -1 if __name__ == '__main__': # l = list(range(1, 14)) # k = 8 # right = len(l) - 1 # res = func(l, k, 0, right) l = list(range(1, 14)) k = 10 right = len(l) - 1 res = foo(l, k) if res == -1: print("查找失败") else: print("查找成功, 第 %d 张拿到" % res)
简单代码
def foo(l, k): left = 0 right = len(l) - 1 while left <= right: mid = (left + right) // 2 if l[mid] > k: right = mid - 1 elif l[mid] < k: left = mid + 1 elif l[mid] == k: return mid return -1 if __name__ == '__main__': l = list(range(13)) print(l) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] print(foo(l, 8)) # 8
总结
冒泡排序
重复走访所有要排序的数据,
依次比较每两个相邻的元素,
如果两者次序错误就交换
重复上面过程 直到没有需要被调换的内容为止
插入排序
将数据插入到已经有序的数据中, 从而得到一个新的有序数据
默认首元素自然有序, 取出下一个元素, 对已经有序的数据从后向前扫描
若扫描的有序数据大于取出数据, 则该有序数据后移
若扫描的有序数据小于取出数据, 则在该有序数据后插入取出数据
若扫描的所有的有序数据大于取出数据, 则在有序数据的首位插入取出数据
特点
数据只移动不交换, 优于冒泡
快速排序
首先任意取一个元素作为关键数据 ( 通常取首元素 )
然后将所有比他小的数据源放在其前面
(从小到大)所有比它大的放在他后面
通过一次排序将要排序的数据分为独立的两部分
然后按照该方法再递归对两部分数据进行快速排序
特点
每次若能均匀分组则排序速度最快, 但是不稳定
本文来自博客园,作者:羊驼之歌,转载请注明原文链接:https://www.cnblogs.com/shijieli/p/10922566.html