排序专题实现

排序专题

**# 快速排序的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