python的常见排序以及O(n)时间内的查找第k大元素

最新推荐文章于 2023-09-25 19:59:09 发布

Pinkmanabcd

最新推荐文章于 2023-09-25 19:59:09 发布

阅读量1.4k

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构与算法刷题

本文链接：https://blog.youkuaiyun.com/Pinkmanabcd/article/details/97926674

数据结构与算法刷题专栏收录该内容

13 篇文章

订阅专栏

本文深入讲解了五种经典排序算法：冒泡排序、插入排序、选择排序、归并排序和快速排序。每种算法都提供了详细的实现代码和注释，帮助读者理解其工作原理和应用场景。此外，还介绍了如何在O(n)时间内查找第k大元素，以及如何使用计数排序处理特定类型的数据。通过本文的学习，你可以掌握这些排序算法的核心概念，并在实际编程中灵活运用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序

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

插入排序

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

选择排序

def selection_sort(l : list):
	length = len(l)
	if length <= 1: return
	for i in range(length):
		min_v,min_index = l[i],i
		for j in range(i,length):
			if l[j] < min_v:
				min_v,min_index = l[j], j
		l[i],l[min_index] = l[min_index],l[i]

归并排序

'''
	对数组实现归并排序
	
	Author by: Lofues
'''

from typing import List


def merge_sort(l : List[int]):
	Merge_Sort(l, 0, len(l) - 1)

def Merge_Sort(l : List[int], low : int, high : int):
	if low < high:
		mid = low + (high - low) // 2
		Merge_Sort(l,low,mid)
		Merge_Sort(l,mid+1,high)
		merge(l,low,mid,high)

def merge(l: List[int], low : int, mid : int, high : int):
	tmp = []
	i, j = low, mid + 1
	while i <= mid and j <= high:
		if l[i] <= l[j]:
			tmp.append(l[i])
			i+=1
		else:
			tmp.append(l[j])
			j+=1
	tmp.extend(l[i:mid+1]) if i <= mid else tmp.extend(l[j:high + 1])
	l[low:high+1] = tmp

快速排序

'''
	实现数组快排

	Author by: Lofues
'''

from typing import List
import random

def quick_sort(a : List[int]):
	Quick_Sort(a, 0, len(a) - 1)

def Quick_Sort(a : List[int], low : int, high: int):
	if low < high:
		# 随机选择pivot的位置
		k = random.randint(low,high)
		a[k], a[high] = a[k], a[high]
		
		pivot = partion(a,low,high)
		Quick_Sort(a,low,pivot-1)
		Quick_Sort(a,pivot+1,high)

def partion(a : List[int], low : int, high : int) -> int:
	pivot = a[high]
	i = j = low
	# 让j从头遍历到high之前的一个位置
	for j in range(low,high):
		if a[i] < pivot:
			a[i], a[j] = a[j], a[i]
			i += 1
	# 交换pivot与a[i]
	a[high], a[i] = a[i], a[high]
	return i

a = [x for x in range(8,0,-1)]
quick_sort(a)
print(a)

基于快速排序中的区间划分思想在O(n)内查找第k大元素

'''
	在O(n)时间内找到第k大元素

	Author by : Lofues
'''

from typing import List

def find_the_kth(l : List[int], k : int) -> int:
	low, high = 0, len(l) - 1
	if k < high + 1:
			key = partion(l,0,high)
			while key + 1 != k:
				if key + 1 < k :
					key = partion(l,key+1,high)
				else:
					key = partion(l,0,key-1)
			return l[key]

def partion(l : List[int], low : int, high : int):
	pivot = l[high]
	i = j = low
	for j in range(low,high):
		if l[j] < pivot:
			l[i], l[j] = l[j], l[i]
			i += 1
	l[i],l[high] = l[high],l[i]
	return i


l = [2,3,7,1,-4,5,11,34,2,54,343,3]
print(l)

print(find_the_kth(l,3))
print(l)

不利用排序算法将大小写以及数字按顺序区分开，不要求有序

'''
	将小写字母放在前面，大写字母放在中间，数字放在最后，不要求序列有序，只要求稳定

	Author by: Lofues
'''

def divide(s : str):
	if not s: return
	s,index_lower = divide_lower_and_unlower(s)
	s = divide_digit_and_notDigit(s,index_lower)
	return s

def divide_lower_and_unlower(s : str):
	l = list(s)
	i, j = 0,0
	for j in range(len(l)):
		if 'a' <= l[j] <= 'z':
			l[i], l[j] = l[j], l[i]
			i += 1
	s = ''.join(l)
	return s,i

def divide_digit_and_notDigit(s : str, index_lower : int):
	i, j = index_lower, index_lower
	l = list(s)
	for j in range(index_lower,len(l)):
		if 'A' <= l[j] <= 'Z':
			l[i],l[j] = l[j],l[i]
			i += 1
	s = ''.join(l)
	return s


s = 'aSD23bcAfeFD3'
s = divide(s)
print(s)

计数排序
关于计数排序的具体细节可去自行百度

'''
	实现计数排序

	Author by: Lofues
'''

def counting_sort(a : list):
	# 数据范围必须为非负整数且大于0
	max_item = a[0]
	for i in range(len(a)):
		if a[i] > max_item:
			max_item = a[i]
	b = [0] * (max_item + 1)
	for i in range(len(a)):
		# b中存储每个值的个数
		b[a[i]] += 1
	for i in range(1,len(b)):
		# b中每个位置存储小于该值的元素个数
		b[i] += b[i-1]
	c = [0] * len(a)
	for i in range(len(a)-1,-1,-1):
		index = b[a[i]] - 1
		b[a[i]] -= 1
		c[index] = a[i]
	a[0:len(a)-1] = c[0:len(c)-1]

a = [6,4,6,3,2,5,7,4,2,5,7,4,2,2,5,3,5,2,35,34,21,12]
counting_sort(a)
print(a)

LeetCode 147 基于链表的插入排序
创建新链表并遍历原始链表进行插入

class ListNode:
     def __init__(self, x):
         self.val = x
        self.next = None

class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        if not head or not head.next: return head
        cur = dummy = ListNode(None)
        while head:
            while cur.next and cur.next.val <=  head.val:
                cur = cur.next
            temp = head
            head = head.next
            temp.next = cur.next
            cur.next = temp
            
            cur = dummy
        return dummy.next