【LeetCode】912. 排序数组-CSDN博客

这篇博客介绍了三种常见的数组排序算法：归并排序、快速排序和堆排序。通过Python代码实现，详细展示了每种排序算法的逻辑。其中，归并排序能正确运行，而快速排序和堆排序在某些情况下可能超时，需要进一步优化。

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

1.题目

简单题，对数组进行排序即可。

2.分析

3. 代码

3.1 归并排序

可AC

from typing import List

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:        
        self.mergeSort(nums,left = 0,right = len(nums)-1)
        # print(nums)
        return nums

    # 归并排序
    # nums 数组
    # left 左端点，right 右端点。这两个端点都是可以取到的
    def mergeSort(self,nums,left,right):
        # 如果区间只剩一个数，直接返回
        if left >= right : 
            return 
        mid = (left + right) // 2         
        # 对左侧进行排序
        self.mergeSort(nums,left,mid)
        # 对右侧进行排序
        self.mergeSort(nums,mid+1,right)
        # 将两个部分合并在一起
        i, j  = left,mid+1
        tmp = [] # 搞个临时数组用于缓存
        # 当条件不满足的时候
        while(i <= mid and j <= right):
            if nums[i] <= nums[j]:
                tmp.append(nums[i])
                i+=1
            else:
                tmp.append(nums[j])
                j+=1
        while(i <= mid):
            tmp.append(nums[i])
            i+=1
        while(j <= right):
            tmp.append(nums[j])
            j+=1
        nums[left:right+1] = tmp

# s = Solution()
# # nums = [5,1,1,2,0,0]
# nums = [5,2,3,1,1,4,2139,112,29]
# s.sortArray(nums)

3.2 快速排序

会超时，搞不懂了。

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        self.quickSort(nums,0,len(nums)-1)
        return nums

    # 快排
    def quickSort(self,nums,left,right):
        if left >= right:
            return 
        mid = self.partition(nums,left,right)
        # print(nums)
        self.quickSort(nums,left,mid-1)
        self.quickSort(nums,mid+1,right)
    
    def partition(self,nums,left,right):		
        #选择pivot的过程不要再以第一个数为基准，如果只以第一个数为基准，会导致一个高时间复杂度。
        mid = (left+right)//2
        # 交换两个未知的值
        nums[mid],nums[left] = nums[left],nums[mid]
        pivot = nums[left]
        # print(pivot)
        while(left < right):
            while(left < right and nums[right] >= pivot):
                right -=1
            nums[left] = nums[right]                        
            while(left < right and nums[left] <= pivot):
                left +=1 
            nums[right] = nums[left]

        nums[right] = pivot
        return right

3.3 堆排序

可惜的是，下面这个代码会超时。不清楚哪里的问题。

import heapq
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        return  self.heapSort(nums)        

    def heapSort(self,nums):
        res = []
        # 只是用于表示要做这么多次的排序
        # 下面的nums.remove(nums[0]) 并不影响这个过程
        for i in range(len(nums)): 
            heapq.heapify(nums) # 将数组转换为堆，默认为小根堆
            res.append(nums[0])
            nums.remove(nums[0])
        return res