排序专题
**# 快速排序的partition函数
**# 一趟排序下来,pivot的左边都是比pivot小的元素**
**# pivot的右边都是比它大的元素,然后分别再对pivot的左右两边执行快速排序**
**# 直到所有元素有序****
def partition(nums, left, right):
# 初始化一个待比较的基准数据
pivot = nums[left]
# 设置两个指针i, j分别指向待排序数组的开头和结尾
i, j = left, right
# 开始遍历待排序数组,结束的循环条件是开头指针超出结尾指针
while i < j:
# 从待排序数据的结尾开始查找比较元素的大小,直到找到一个元素比pivot小
while i < j and nums[j] >= pivot:
j -= 1
# 退出上层的while循环表示,找到了一个元素nums[j]比pivot小
# 让nums[j]放在第i个位置上
nums[i] = nums[j]
# 由于刚才的数据交换,指针现在位于第i个位置,
# 所以从待排序数据的第i个位置开始查找比较元素的大小,直到找到一个元素比pivot大
while i < j and nums[i] <= pivot:
i += 1
# 找到了一个元素nums[i]大于pivot
# 将这个nums[i]赋值给pivot右边的第j个元素
nums[j] = nums[i]
# 一趟快速排序结束之后,pivot的左边都是比它小的元素,右边都是比它大的元素
# pivot放在中间的位置,最外层while循环结束,此时i和j相等,所以i和j的索引都可以
# 用来赋值pivot
nums[i] = pivot
# 可以返回此时的pivot在数组中的索引
return i
# 随机初始化pivot的索引
def partition2(nums, left, right):
#随机初始化
pivot_index = random.randint(left, right)
nums[pivot_index], nums[left] = nums[left], nums[pivot_index]
i, j = left, right
pivot = nums[left]
while i < j:
while i < j and pivot <= nums[j]:
j -= 1
nums[i] = nums[j]
while i < j and pivot >= nums[i]:
i += 1
nums[j] = nums[i]
nums[i] = pivot
return i
快速排序
**# 快速排序**
def quick_sort(nums, left, right):
if left < right:
index = partition(nums, left, right)
quick_sort(nums, left, index - 1)
quick_sort(nums, index + 1, right)
快速选择
def topk_split(self, nums, k, left, right):
# 将快速排序改成快速选择,希望寻找到一个位置index
# 这个位置左边是k个比这个位置上的数更小的数,右边是n-k-1个比该位置上的数大的数
if left < right:
index = self.partition(nums, left, right)
if index == k:
return
elif index < k:
self.topk_split(nums, k, index + 1, right)
else:
self.topk_split(nums, k, left, index - 1)
topk切分
利用上面的三个函数解决topk的问题
返回前k小的数
def topk_smalls(nums, k):
topk_split(nums, k, 0, len(nums)-1)
return nums[:k]
获取第k小的数
def topk_small(nums, k):
topk_split(nums, k, 0, len(nums)-1)
return nums[k-1]
获得前k大的数
def topk_larges(nums, k):
#parttion是按从小到大划分的,如果index左边为前n-k个小的数,则index右边为前k个大的数
#把k换成len(nums)-k
topk_split(nums, len(nums)-k, 0, len(nums)-1)
return nums[len(nums)-k:]
获得第k大的数
def topk_large(nums, k):
#parttion是按从小到大划分的,如果让index左边为前n-k个小的数,则index右边为前k个大的数
#把k换成len(nums)-k
topk_split(nums, len(nums)-k, 0, len(nums)-1)
return nums[len(nums)-k]
只排序前k个小的数
#获得前k小的数O(n),进行快排O(klogk)
def topk_sort_left(nums, k):
topk_split(nums, k, 0, len(nums)-1)
topk = nums[:k]
quicksort(topk, 0, len(topk)-1)
#只排序前k个数字
return topk+nums[k:]
只排序后k个大的数
#获得前n-k小的数O(n),进行快排O(klogk)
def topk_sort_right(nums, k):
topk_split(nums, len(nums)-k, 0, len(nums)-1)
topk = nums[len(nums)-k:]
quicksort(topk, 0, len(topk)-1)
#只排序后k个数字
return nums[:len(nums)-k]+topk
归并排序
也是使用递归的方法,先分,再治,分就是一分为二
治的步骤举例,看上图中的最后一次合并,要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列,合并为最终序列[1,2,3,4,5,6,7,8]
代码实现:
class Solution:
def sortArray(self, nums: List[int]) -> List[int]:
# 定义一个函数,用于归并排序
def merge_sort(array, left, right):
# 递归的结束条件,当元素都排序完的时候
if left >= right:
return
# 归并排序的分的阶段,就是一分为二
mid = left + (right - left) // 2
# 递归的对一分为二的两边继续使用归并排序
merge_sort(array, left, mid)
merge_sort(array, mid + 1, right)
# 定义两个指针,分别指向待排序数组的左右半边的开始位置
i, j = left, mid + 1
# 存储一趟的归并排序结果,最后赋值给原数组
temp = []
# 开始治的阶段,其实就是比较排序
while i <= mid and j <= right:
# 添加较小者,就是从大到小排序
if array[i] <= array[j]:
temp.append(array[i])
i += 1
else:
temp.append(array[j])
j += 1
# 上述比较,可能存在左右半边剩余还没插入temp数组的情况
# 将剩余的元素插入temp数组即可
temp += array[i : mid + 1]
temp += array[j : right + 1]
# 将完成一次排序的数组结果分配给原数组
array[left : right + 1] = temp
merge_sort(nums, 0, len(nums) - 1)
return nums
参考文献:
https://leetcode-cn.com/problems/kth-largest-element-in-an-array/solution/ji-yu-kuai-pai-de-suo-you-topkwen-ti-jia-ylsd/
https://leetcode-cn.com/problems/sort-an-array/solution/duo-chong-pai-xu-yi-wang-da-jin-kuai-pai-wgz4/
https://www.cnblogs.com/chengxiao/p/6194356.html