1. 冒泡排序:
这是一种简单的排序算法,它重复地遍历待排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。
# 1. 定义函数, 表示冒泡排序.
def bubble_sort(my_list):
# 定义变量, 记录: 列表的长度.
n = len(my_list)
# 开始排序, 遍历. 外循环充当: 比较的轮数
for i in range(0, n - 1):
count = 0
# 内循环, 充当: 每轮比较的次数.
for j in range(0, n - i - 1):
# 具体的比较过程. j 和 j + 1的元素对比.
if my_list[j] > my_list[j + 1]:
# 走这里, 是具体的交换动作.
count += 1 # 表示交换1次.
my_list[j], my_list[j+1] = my_list[j+1], my_list[j]
# 如果count是0, 说明已经是最终排序结果了, 无需交换, 结束即可.
if count == 0:
break
# 2. 在main方法中测试.
if __name__ == '__main__':
# 3. 定义列表, 记录: 要排序的元素.
# my_list = [11, 33, 55, 22, 44]
my_list = [11, 22, 33, 44, 55]
print(f'排序前: {my_list}')
# 4. 调用 排序算法, 对列表元素排序.
bubble_sort(my_list)
# 5. 打印排序结果.
print(f'排序后: {my_list}')
2. 选择排序:
在未排序序列中找到最小(或最大)元素,存放到排序序列的起始位置,然后再从剩余未排序元素中继续寻找最小(或最大)元素,然后放到已排序序列的末尾。
# 1. 定义函数, 表示选择排序.
def select_sort(my_list):
# 获取列表长度.
n = len(my_list)
# 外循环, 控制: 比较的轮数
for i in range(0, n - 1):
# 定义变量 min_index, 用来表示最小值的索引.
min_index = i
# 内循环, 控制每轮比较的次数.
for j in range(i + 1, n):
# 1.5 具体的比较过程, 如果 j对应的元素 比 min_index对应的元素小, 就将j的值赋值给min_index
if my_list[j] < my_list[min_index]:
min_index = j # min_index 永远记录: 最小值所在的位置(索引)
# 判断min_index的值是否有修改, 如果有修改, 说明最小值有变动, 交换即可.
if min_index != i:
my_list[i], my_list[min_index] = my_list[min_index], my_list[i]
# 2. 在main方法中测试.
if __name__ == '__main__':
# 3. 定义列表, 记录: 要排序的元素.
my_list = [11, 33, 55, 22, 44]
print(f'排序前: {my_list}')
# 4. 调用 排序算法, 对列表元素排序.
select_sort(my_list)
# 5. 打印排序结果.
print(f'排序后: {my_list}')
3. 插入排序:
将未排序数据按其排序码依次插入到已排序数据的合适位置,直到所有数据均插入到数组中。
# 1. 定义函数, 实现: 插入排序.
def insert_sort(my_list):
# 获取列表的长度.
n = len(my_list)
# 通过外循环, 表示: 有序列表(中的每个值)
for i in range(1, n):
# 通过内循环, 依次从无序列表中逐个获取每个值, 然后和 有序列表的(每个)值进行比较.
for j in range(i, 0, -1):
# 如果 无序列表的值 小于 有序列表的值, 就交换.
if my_list[j] < my_list[j - 1]:
# 具体交换过程.
my_list[j], my_list[j - 1] = my_list[j - 1], my_list[j]
else:
break
# 2. 在main方法中进行测试.
if __name__ == '__main__':
# 定义列表, 记录要排序的数据.
my_list = [11, 33, 22, 55, 44]
# 打印排序前的结果.
print(f'排序前: {my_list}')
# 排序
insert_sort(my_list)
# 打印排序后的结果.
print(f'排序后: {my_list}')
4. 快速排序:
通过一趟排序将待排序的数据分割成独立的两部分,其中一部分的所有数据都比另一部分的所有数据要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
# 1. 定义函数, 实现: 快速排序.
def quick_sort(my_list, start, end):
# 递归出口, 只要start >= end, 说明排好顺序了, 程序结束.
if start >= end:
return
# 定义分界值, 假定第1个元素为分界值.
mid = my_list[start] # 默认: mid = my_list[0]
# 定义游标, 表示左边的 和 右边的数据.
left = start
right = end
# 通过循环, 获取到(列表)每个数据.
while left < right:
# 将大于或等于分界值的数据集中到数组右边,
while my_list[right] >= mid and left < right:
right -= 1
my_list[left] = my_list[right]
# 小于分界值的数据集中到数组的左边
while my_list[left] < mid and left < right:
left += 1
my_list[right] = my_list[left]
# 循环结束后, 说明: 分界值的位置找到了.
my_list[left] = mid
# 将该部分数据分成左右两部分,同样在左边放置较小值, 右边放置较大值, 右侧的数组数据也做类似处理
# 处理分界后, 左边的数据(即: 比分界值小的数据)
quick_sort(my_list, start, left - 1)
# 处理分界后, 右边的数据(即: 比分界值大的数据)
quick_sort(my_list, right + 1, end)
# 2. 在main方法中进行测试.
if __name__ == '__main__':
# 定义列表, 记录要排序的数据.
my_list = [11, 33, 22, 55, 44]
# 打印排序前的结果.
print(f'排序前: {my_list}')
# 排序
quick_sort(my_list, 0, len(my_list) - 1)
# 打印排序后的结果.
print(f'排序后: {my_list}')