Python常用排序算法

news2025/4/18 21:10:24

1. 冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较相邻的元素，如果他们的顺序错误就交换他们。

def bubble_sort(arr):
	# 遍历所有数组元素
	for i in range(len(arr)):
		# 最后i个元素是已经排序好的
		for j in range(0, len(arr)-i-1):
			# 如果当前元素大于下一个元素，则交换位置
			if arr[j] > arr[j+1]:
				arr[j], arr[j+1] = arr[j+1], arr[j]
	return arr

arr = [11, 32, 21, 67, 54, 19]
sorted_arr = bubble_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [11, 19, 21, 32, 54, 67]

复杂度分析

  1. 时间复杂度：
  • 最坏情况：O(n2)（完全逆序）
  • 最好情况：O(n)
  • 平均情况：O(n2)
  1. 空间复杂度：O(1)（原地排序）

2. 选择排序

选择排序是一种简单直观的排序算法，它的工作原理是每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排序完毕。

def select_sort(arr):
	# 遍历所有数组元素
	for i in range(len(arr)):
		# 找到剩余未排序部分的最小元素索引
		min_index = i
		for j in range(i+1, len(arr)):
			if arr[j] < arr[min_index]:
				min_index = j
		# 将找到的最小元素与第i个位置的元素交换
		arr[i], arr[min_index] =  arr[min_index], arr[i]
	return arr

arr = [11, 32, 21, 67, 54, 19]
sorted_arr = select_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [11, 19, 21, 32, 54, 67]

复杂度分析

  1. 时间复杂度：O(n2)
  2. 空间复杂度：O(1)（原地排序）

3. 插入排序

插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，在已排序序列中从后向前扫描，找到相应位置并插入。

def insert_sort(arr):
	# 遍历从1到倒数第二个元素
	for i in range(1, len(arr)):
		# 当前需要插入的元素
		key = arr[i]
		# 已排序部分的最后一个元素索引
		j = i - 1
		# 将arr[i]与已排序部分的元素逐个比较，如果比key大则后移一位
		while j >= 0 and key < arr[j]:
			arr[j + 1] = arr[j]
			j -= 1
		# 找到合适位置，插入key
		arr[j + 1] = key
	return arr

arr = [11, 32, 21, 67, 54, 19]
sorted_arr = insert_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [11, 19, 21, 32, 54, 67]

复杂度分析

  1. 时间复杂度：
  • 最坏情况：O(n2)（当数组是逆序时）
  • 最好情况：O(n)（当数组已经有序时）
  • 平均情况：O(n2)
  1. 空间复杂度：O(1)（原地排序）

4. 快速排序

快速排序是一种高效的排序算法，采用分治法策略。首先任意选取一个元素作为基准数据，将待排序列表中的数据分割成独立的两部分，比基准数据小的放在它左边，比基准数据大的放在它右边，此时第一轮数据排序完成。然后再按照此方法对两边的数据分别进行分割，直至被分割的数据只有一个或者零个时，递归结束。

def quick_sort(arr):
	if len(arr) <= 1:
		return arr
	# 选择中间元素作为基准值
	pivot = arr[len(arr)//2]
	left = [x for x in arr if x < pivot]
	middle = [x for x in arr if x == pivot]
	right = [x for x in arr if x > pivot]
	
	return quick_sort(left) + middle + quick_sort(right)

arr = [11, 32, 21, 67, 54, 19]
sorted_arr = quick_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [11, 19, 21, 32, 54, 67]

复杂度分析

  1. 时间复杂度：
  • 最坏情况：O(n2)（当分区极度不平衡时）
  • 最好情况：O(n log n)
  • 平均情况：O(n log n)
  1. 空间复杂度：O(n)（创建了新的列表）

5. 归并排序

归并排序是一种基于分治策略的高效排序算法，将数组不断地分成两半，然后递归地对两半进行排序，最后将排序好的两半合并在一起。

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    # 分割阶段
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])

    # 合并阶段
    return merge(left, right)
    

def merge(left, right):
    """
    合并两个已排序的列表
    """
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    # 添加剩余元素
    result.extend(left[i:])
    result.extend(right[j:])
    return result

arr = [38, 27, 43, 3, 9, 82, 10]
sorted_arr = merge_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [3, 9, 10, 27, 38, 43, 82]

复杂度分析

  1. 时间复杂度：O(n log n)
  2. 空间复杂度: O(n)（需要额外空间存储临时数组）

6. 堆排序

堆排序是一种基于二叉堆数据结构的高效排序算法。堆是一种特殊的完全二叉树，其中每个父节点的值都大于或等于其子节点的值（称为最大堆）或每个父节点的值都小于或等于其子节点的值（称为最小堆）。

import heapq

def heap_sort(arr):
	# 构建最小堆
	heapq.heapify(arr)
	return [heapq.heappop(arr) for _ in range(len(arr))]

arr = [12, 11, 15, 3, 21, 9]
sorted_arr = heap_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [3, 9, 11, 12, 15, 21]

复杂度分析

  1. 时间复杂度:
  • 建堆过程：O(n)
  • 每次堆化：O(log n)
  • 总体时间复杂度：O(n log n)
  1. 空间复杂度: O(1)（原地排序）

7. 计数排序

计数排序是一种非比较排序算法，适用于对一定范围内的整数进行排序。它统计数组中每个元素出现的次数，然后根据统计结果将元素放回正确的位置。

def count_sort(arr):
	if len(arr) == 0:
		return arr
	# 找到数组中的最大值和最小值
	max_val = max(arr)
	min_val = min(arr)
	# 创建计数数组，初始化为0
	count = [0] * (max_val - min_val + 1)
	# 统计每个元素出现的次数
	for num in arr:
		count[num - min_val] += 1
	# 重建排序后的数组
	sorted_arr = []
	for i in range(len(count)):
		sorted_arr.extend([i + min_val] * count[i])
	
	return sorted_arr

arr = [4, 2, 5, 1, 8]
sorted_arr = count_sort(arr)
print("排序后为：", sorted_arr)

输出结果：
排序后为： [1, 2, 4, 5, 8]

复杂度分析

  1. 时间复杂度：O(n+k)，其中n是元素数量，k是数据范围
  2. 空间复杂度：O(n+k)

8. 基数排序

基数排序是一种非比较型整数排序算法，它通过将整数按位切割成不同的数字，然后按每个位数分别比较排序。基数排序可以采用最低位优先（LSD）或最高位优先（MSD）两种方式。

def radix_sort(arr):
	# 找到数组中的最大数，确定排序的轮数
	max_num = max(arr)
	# 从个位开始
	exp = 1
	while max_num // exp > 0:
		counting_sort_by_digit(arr, exp)
		exp *= 10
	return arr

def counting_sort_by_digit(arr, exp):
	n = len(arr)
	output = [0] * n
	count = [0] * 10
	# 统计当前位数的数字出现次数
	for num in arr:
		digit = (num // exp) % 10
		count[digit] += 1
	# 计算累加计数
	for i in range(1, 10):
		count[i] += count[i-1]
	# 反向填充输出数组（保证稳定性）
	for i in range(n-1, -1, -1):
		digit = (arr[i] // exp) % 10
		output[count[digit] - 1] = arr[i]
		count[digit] -= 1
	# 将排序结果复制回原数组
	for i in range(n):
		arr[i] = output[i]

arr = [170, 45, 75, 90, 802, 24, 2, 66]
sorted_arr = radix_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [2, 24, 45, 66, 75, 90, 170, 802]

复杂度分析

  1. 时间复杂度：O(d*(n+k))，其中d是最大数字的位数，n是元素数量，k是基数
  2. 空间复杂度：O(n+k)

9. 桶排序

桶排序是一种分布式排序算法，它将元素分到有限数量的桶里，每个桶再分别排序。

def bucket_sort(arr, bucket_size=5):
	if len(arr) == 0:
		return arr
	# 找到最大值和最小值
	max_val = max(arr)
	min_val = min(arr)
	# 计算桶的数量
	bucket_count = (max_val - min_val) // bucket_size + 1
	buckets = [[] for _ in range(bucket_count)]
	# 将元素分配到各个桶中
	for num in arr:
		index = (num - min_val) // bucket_size
		buckets[index].append(num)
	# 对每个桶进行排序
	sorted_arr = []
	for bucket in buckets:
		# 使用内置的sorted函数
		sorted_arr.extend(sorted(bucket))
		
	return sorted_arr

arr = [29 ,25, 13, 21, 8, 43]
sorted_arr = bucket_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [8, 13, 21, 25, 29, 43]

复杂度分析

  1. 时间复杂度：
  • 平均情况：O(n+k)，其中k是桶的数量
  • 最坏情况：O(n2)（当所有元素都分配到同一个桶中）
  1. 空间复杂度：O(n+k)

10. 希尔排序

希尔排序是插入排序的一种高效改进版本，也称为缩小增量排序。它通过将原始列表分割成多个子列表来进行插入排序，随着算法的进行，子列表的长度逐渐增大，最终整个列表变为一个子列表完成排序。

def shell_sort(arr):
	n = len(arr)
	# 初始间隔（gap）设置为数组长度的一半
	gap = n // 2
	while gap > 0:
		# 对各个间隔分组进行插入排序
		for i in range(gap, n):
			temp = arr[i]
			j = i
			# 对子列表进行插入排序
			while j >= gap and arr[j - gap] > temp:
				arr[j] = arr[j - gap]
				j -= gap
			arr[j] = temp
		# 缩小间隔
		gap = gap // 2
	return arr

arr = [9 , 8, 3, 6, 5, 7, 1]
sorted_arr = shell_sort(arr)
print("排序后为:", sorted_arr)

输出结果：
排序后为: [1, 3, 5, 6, 7, 8, 9]

复杂度分析

  1. 时间复杂度：
  • 平均情况：O(n1.3)到O(n1.5)
  • 最坏情况：O(n*n)
  • 最好情况：O(n log n)
  1. 空间复杂度：O(1)（原地排序）

11. 拓扑排序

拓扑排序是针对有向无环图的线性排序算法，使得对于图中的每一条有向边（u, v）,u在排序中总是位于v的前面。

from collections import deque

def topo_sort_kahn(graph):
    # 计算所有节点的入度
    in_degree = {node: 0 for node in graph}
    for node in graph:
        for neighbor in graph[node]:
            in_degree[neighbor] += 1
    # 初始化队列，将所有入度为0的节点加入队列
    queue = deque([node for node in graph if in_degree[node] == 0])
    topo_order = []
    while queue:
        current = queue.popleft()
        topo_order.append(current)
        # 减少所有邻居的入度
        for neighbor in graph[current]:
            in_degree[neighbor] -= 1
            # 如果邻居的入度变为0，加入队列
            if in_degree[neighbor] == 0:
                queue.append(neighbor)
    # 检查是否所有节点都被排序（无环）
    if len(topo_order) == len(graph):
        return topo_order
    else:
        return []  # 图中存在环，无法进行拓扑排序
# 定义有向无环图（邻接表表示）
graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}

print("Kahn算法拓扑排序结果:", topo_sort_kahn(graph))

输出结果：
Kahn算法拓扑排序结果: [‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’]

复杂度分析

  1. 时间复杂度：O(V+E),其中V是顶点数，E是边数
  2. 空间复杂度：O(V)（存储入度或递归栈）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2332443.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

ISP--Demosaicking

ISP--Demosaicking

文章目录 前言算法解释简单的线性插值代码实现 色差法和色比法基于方向加权的方法RB缺失的G通道的插值RB缺失的BR的插值G缺失的BR的插值代码实现 基于边缘检测的方法计算缺失的G计算缺失的RB值/计算缺失的G值 前言 人眼之所以有能感受到自然界的颜色&#xff0c;是因为人眼的感…
阅读更多...
国标GB28181协议EasyCVR视频融合平台：5G时代远程监控赋能通信基站安全管理

国标GB28181协议EasyCVR视频融合平台：5G时代远程监控赋能通信基站安全管理

一、背景介绍 随着移动通信行业的迅速发展&#xff0c;无人值守的通信基站建设规模不断扩大。这些基站大多建于偏远地区&#xff0c;周边人迹罕至、交通不便&#xff0c;给日常的维护带来了极大挑战。其中&#xff0c;位于空旷地带的基站设备&#xff0c;如空调、蓄电池等&…
阅读更多...
模拟-与-现实协同训练：基于视觉机器人操控的简单方法

模拟-与-现实协同训练：基于视觉机器人操控的简单方法

25年3月来自 UT Austin、Nvidia、UC Berkeley 和纽约大学的论文“Sim-and-Real Co-Training: A Simple Recipe for Vision-Based Robotic Manipulation”。 大型现实世界机器人数据集在训练通才机器人模型方面拥有巨大潜力&#xff0c;但扩展现实世界人类数据收集既耗时又耗资…
阅读更多...
WRS-PHM电机智能安康系统：为浙江某橡胶厂构筑坚实的生产防线

WRS-PHM电机智能安康系统：为浙江某橡胶厂构筑坚实的生产防线

以行业工况为背景 一、顾客工厂的背景 浙江某橡胶厂以电机为中心生产设备必须连续平稳运行。但由于缺乏有效的故障预警体系&#xff0c;电机故障就像潜伏着的“不定时炸弹”,不但不时地造成生产流程的中断&#xff0c;也使对生产进行管理异常艰难&#xff0c;对持续安全生产提…
阅读更多...
将 CrewAI 与 Elasticsearch 结合使用

将 CrewAI 与 Elasticsearch 结合使用

作者&#xff1a;来自 Elastic Jeffrey Rengifo 学习如何使用 CrewAI 为你的代理团队创建一个 Elasticsearch 代理&#xff0c;并执行市场调研任务。 CrewAI 是一个用于编排代理的框架&#xff0c;它通过角色扮演的方式让多个代理协同完成复杂任务。 如果你想了解更多关于代理…
阅读更多...
Spring 的 IoC 和 DI 详解：从零开始理解与实践

Spring 的 IoC 和 DI 详解：从零开始理解与实践

Spring 的 IoC和 DI 详解&#xff1a;从零开始理解与实践 一、IoC&#xff08;控制反转&#xff09; 1、什么是 IoC&#xff1f; IoC 是一种设计思想&#xff0c;它的核心是将对象的创建和管理权从开发者手中转移到外部容器&#xff08;如 Spring 容器&#xff09;。通过这种…
阅读更多...
ZYNQ笔记（四）：AXI GPIO

ZYNQ笔记（四）：AXI GPIO

版本&#xff1a;Vivado2020.2&#xff08;Vitis&#xff09; 任务&#xff1a;使用 AXI GPIO IP 核实现按键 KEY 控制 LED 亮灭&#xff08;两个都在PL端&#xff09; 一、介绍 AXI GPIO (Advanced eXtensible Interface General Purpose Input/Output) 是 Xilinx 提供的一个可…
阅读更多...
实操（环境变量）Linux

实操（环境变量）Linux

环境变量概念 我们用语言写的文件编好后变成了程序&#xff0c;./ 运行的时候他就会变成一个进程被操作系统调度并运行&#xff0c;运行完毕进程相关资源被释放&#xff0c;因为它是一个bash的子进程&#xff0c;所以它退出之后进入僵尸状态&#xff0c;bash回收他的退出结果&…
阅读更多...
Word / WPS 页面顶部标题 段前间距 失效 / 不起作用 / 不显示，标题紧贴页眉 问题及解决

Word / WPS 页面顶部标题 段前间距 失效 / 不起作用 / 不显示，标题紧贴页眉 问题及解决

问题描述&#xff1a; 在 Word 或者 WPS 里面&#xff0c;如果不是新的一节&#xff0c;而是位于新的一页首行时&#xff0c;不管怎么设置段前间距&#xff0c;始终是失效的&#xff0c;实际段前间距一直是零。 解决方案&#xff1a; 查询了很多方案均无法解决问题&#xff…
阅读更多...
Linux自行实现的一个Shell(15)

Linux自行实现的一个Shell(15)

文章目录 前言一、头文件和全局变量头文件全局变量 二、辅助函数获取用户名获取主机名获取当前工作目录获取最后一级目录名生成命令行提示符打印命令行提示符 三、命令处理获取用户输入解析命令行执行外部命令 四、内建命令添加环境变量检查和执行内建命令 五、初始化初始化环境…
阅读更多...
在 Q3D 中提取汇流条电感

在 Q3D 中提取汇流条电感

汇流条排简介和设计注意事项 汇流条排是用于配电的金属导体&#xff0c;在许多应用中与传统布线相比具有设计优势。在设计母线排时&#xff0c;必须考虑几个重要的因素&#xff1a; 低电感&#xff1a;高频开关内容会导致无功损耗&#xff0c;从而降低效率电容&#xff1a;管…
阅读更多...
MySQL：事务的理解

MySQL：事务的理解

一、CURD不加控制&#xff0c;会有什么问题 &#xff08;1&#xff09;因为&#xff0c;MySQL里面存的是数据&#xff0c;所以很有可能会被多个客户访问&#xff0c;所以mysqld可能一次会接受到多个关于CURD的请求。&#xff08;2&#xff09;且mysql内部是采用多线程来完成数…
阅读更多...
python 基础：句子缩写

python 基础：句子缩写

n int(input()) for _ in range(n):words input().split()result ""for word in words:result word[0].upper()print(result)知识点讲解 input()函数 用于从标准输入&#xff08;通常是键盘&#xff09;读取用户输入的内容。它返回的是字符串类型。例如在代码中…
阅读更多...
Ruoyi-vue plus 5.2.2 flowble 结束节点异常错误

Ruoyi-vue plus 5.2.2 flowble 结束节点异常错误

因业务要求&#xff0c; 我在结束节点的结束事件中&#xff0c;制作了一个归档的事件&#xff0c;来执行一个业务。 始终都会报错&#xff0c; 错误信息 ${archivTemplateListener} did not resolve to an implementation of interface org.flowable.engine.delegate.Execution…
阅读更多...
Sublime Text使用教程（用Sublime Text编写C语言程序）

Sublime Text使用教程（用Sublime Text编写C语言程序）

Sublime Text 是一款当下非常流行的文本编辑器&#xff0c;其功能强大&#xff08;提供有众多的插件&#xff09;、界面简洁、还支持跨平台使用&#xff08;包括 Mac OS X、Linux 和 Windows&#xff09;。 在程序员眼中&#xff0c;Sublime Text 不仅仅是一个文本编辑器&…
阅读更多...
【1】k8s集群管理系列--包应用管理器之helm

【1】k8s集群管理系列--包应用管理器之helm

一、helm概述 Helm核心是模板&#xff0c;即模板化K8s YAML文件。 通过模板实现Chart高效复用&#xff0c;当部署多个应用时&#xff0c;可以将差异化的字段进行模板化&#xff0c;在部署时使用-f或 者–set动态覆盖默认值&#xff0c;从而适配多个应用 helm工作流程&#xf…
阅读更多...
Mysql表的操作（2）

Mysql表的操作（2）

1.去重 select distinct 列名 from 表名 2.查询时排序 select 列名 from 表名 order by 列名 asc/desc; 不影响数据库里面的数据 错误样例 &#xff1a; 但结果却有点出乎意料了~为什么会失败呢&#xff1f; 其实这是因为书写的形式不对&#xff0c;如果带了引号&#xff0c;…
阅读更多...
智能物联网网关策略部署

智能物联网网关策略部署

实训背景 某智慧工厂需部署物联网网关&#xff0c;实现以下工业级安全管控需求&#xff1a; 设备准入控制&#xff1a;仅允许注册MAC地址的传感器接入&#xff08;白名单&#xff1a;AA:BB:CC:DD:EE:FF&#xff09;。协议合规性&#xff1a;禁止非Modbus TCP&#xff08;端口…
阅读更多...
Java学习总结-线程池

Java学习总结-线程池

线程池是什么&#xff1f; 线程池就是一个可以复用线程的技术。 假若不用线程池的问题&#xff1a;创建新线程开销很大&#xff0c;不能来一个任务就就创建一个新线程。 如何创建线程池对象&#xff1f; 方法一&#xff1a;使用ExecutorService的实现类ThreadPoolExecutor创…
阅读更多...
基于CNN-BiLSTM-GRU的深度Q网络（Deep Q-Network，DQN）求解移动机器人路径规划，MATLAB代码

基于CNN-BiLSTM-GRU的深度Q网络（Deep Q-Network，DQN）求解移动机器人路径规划，MATLAB代码

一、深度Q网络&#xff08;Deep Q-Network&#xff0c;DQN&#xff09;介绍 1、背景与动机 深度Q网络&#xff08;DQN&#xff09;是深度强化学习领域的里程碑算法&#xff0c;由DeepMind于2013年提出。它首次在 Atari 2600 游戏上实现了超越人类的表现&#xff0c;解决了传统…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023