排序算法(python)

排序算法

冒泡排序

一次比较相邻的两个数,每轮之后末尾的数字是确定的。

  • 时间复杂度为 O ( n 2 ) O(n^2) O(n2),空间复杂度为 O ( 1 ) O(1) O(1),稳定。
python 复制代码
def BUB(nums):
	for i in range(len(nums)):
		count = 0
		for j in range(len(nums)-i-1):
			if nums[j] > nums[j+1]:
				nums[j], nums[j+1] = nums[j+1], nums[j]
				count += 1
		# count是为了记录该轮是否有修改的,若没有修改,则说明当前数组已经满足条件,不需要再进行交换了。
		if count == 0:
			break
	return nums

选择排序

选择排序是每轮在剩余的元素中,找到最小的元素交换位置。

  • 时间复杂度为 O ( n 2 ) O(n^2) O(n2),空间复杂度为 O ( 1 ) O(1) O(1),不稳定。
python 复制代码
def selection(nums):
	for i in range(len(nums)-1):
		for j in range(i+1, len(nums)):
			if nums[i] > nums[j]:
				nums[i], nums[j] = nums[j], nums[i]
	return nums

插入排序

插入排序是默认前面的序列是有序的,然后将后面的每个数字依次与前面有序的序列进行比较

  • 时间复杂度为 O ( n 2 ) O(n^2) O(n2),空间复杂度为 O ( 1 ) O(1) O(1),稳定。
python 复制代码
def insertSort(nums):
	for i in range(len(nums)-1):
		for j in range(i+1, 0, -1):
			if nums[j] < nums[j-1]:
				nums[j], nums[j-1] = nums[j-1], nums[j]
			else:
				break
	return nums

希尔排序

希尔排序是对插入排序的优化,它选择了一个增量(len(nums)//2),然后按照这个增量选取等差数列,每轮对每个等差数列进行排序,然后将增量缩小,重复进行排列,直到增量缩小为1。

  • 时间复杂度为 O ( n l o g 2 n ) O(nlog_2^n) O(nlog2n),空间复杂度为 O ( 1 ) O(1) O(1),稳定。
python 复制代码
def xier(nums):
	l = len(nums)
	gap = l//2
	while gap>0:
		for i in range(gap, l):
			temp = nums[i]
			j = i
			# j-gap就相当于等差数列进行排序比较
			while j-gap>0 and temp < nums[j-gap]:
				nums[j] = nums[j-gap]
				j = j-gap
			nums[j]=temp
		gap-=1
	return nums

归并排序

合并两个已经排好序的序列以得到结果。是一个递归的过程。

  • 时间复杂度为 O ( n l o g n ) O(nlogn) O(nlogn),空间复杂度为 O ( n ) O(n) O(n),稳定。
python 复制代码
# 合并两个有序的数组
def merge_two(s1,s2,s):
	i, j = 0, 0
	while (i+j) < len(s):
		# j==len(s2)时说明s2走完了,或者s1没走完并且s1中该位置是最小的
		if j==len(s2) or (i<len(s1) and s1[i] < s2[j]):
			s[i+j] = s1[i]
			i += 1
		else:
			s[i+j] = s2[j]
			j += 1
def merge(s):
	l = len(s)
	if l<2:
		return
	mid = l//2
	s1 = s[0:mid]
	s2 = s[mid:l]
	merge(s1)
	merge(s2)
	merge_two(s1, s2, s)

快速排序

快速排序需要一个基准元素,以及左右两个指针l,r,首先从右端元素开始与基准元素进行比较,找到比基准元素小的数字,放到左端,然后从左端开始寻找比右端大的元素放到r的位置。一轮之后,基准元素左端都是比基准元素小的,右端都是比基准元素大的。然后再依次遍历基准元素左边和右边的序列。

  • 时间复杂度为 O ( n l o g n ) O(nlogn) O(nlogn),空间复杂度为 O ( 1 ) O(1) O(1),不稳定。
python 复制代码
def quick_sort(nums, start, end):
	if start >= end:
		return
	pivot = nums[start]
	l, r = start, end
	while l<r:
		while l<r and nums[r] > pivot:
			r-=1
		nums[l] = nums[r]
		while l<r and nums[l] < pivot:
			l+=1
		nums[r] = nums[l]
	nums[l] = pivot
	quick_sort(nums, start, l)
	quick_sort(nums, l+1, end)
相关推荐
MessiGo6 分钟前
Python 爬虫 (1)基础 | 基础操作
开发语言·python
肥猪猪爸30 分钟前
使用卡尔曼滤波器估计pybullet中的机器人位置
数据结构·人工智能·python·算法·机器人·卡尔曼滤波·pybullet
readmancynn42 分钟前
二分基本实现
数据结构·算法
萝卜兽编程44 分钟前
优先级队列
c++·算法
盼海1 小时前
排序算法(四)--快速排序
数据结构·算法·排序算法
LZXCyrus1 小时前
【杂记】vLLM如何指定GPU单卡/多卡离线推理
人工智能·经验分享·python·深度学习·语言模型·llm·vllm
Enougme1 小时前
Appium常用的使用方法(一)
python·appium
一直学习永不止步1 小时前
LeetCode题练习与总结:最长回文串--409
java·数据结构·算法·leetcode·字符串·贪心·哈希表
懷淰メ1 小时前
PyQt飞机大战游戏(附下载地址)
开发语言·python·qt·游戏·pyqt·游戏开发·pyqt5
hummhumm1 小时前
第 22 章 - Go语言 测试与基准测试
java·大数据·开发语言·前端·python·golang·log4j