215. 数组中的第K个最大元素(排序算法)

215. 数组中的第K个最大元素

难度中等984收藏分享切换为英文接收动态反馈

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

说明:

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

1. #冒泡排序(超时)O（n^2）最好O(N)；空间：O(1)

class Solution:

    def findKthLargest(self, nums: List[int], k: int) -> int:

       

        le = len(nums)

        

        for i in range(le):

            flag = 0

            for j in range(0,le-i-1):

                if nums[j+1] < nums[j]:

                    tmp = nums[j+1]

                    nums[j+1] = nums[j]

                    nums[j] = tmp

                    flag = 1

            if flag == 0:

                break

        return nums[le-k]

            

2.快排：

一、快速排序算法的基本特性
时间复杂度：O（n*lgn）
最坏：O（n^2）
空间复杂度：O（n*lgn）
不稳定。

快速排序是一种排序算法，对包含n个数的输入数组，平均时间为O（nlgn），最坏情况是O（n^2）。
通常是用于排序的最佳选择。因为，基于比较的排序，最快也只能达到O（nlgn）。

class Solution:

    def findKthLargest(self, nums: List[int], k: int) -> int:

        le = len(nums)

        nums.sort()

        return nums[le-k]

自己实现快排：

class Solution:

    def findKthLargest(self, nums: List[int], k: int) -> int:

        #冒泡排序

        le = len(nums)

        # nums.sort()

        # return nums[le-k]

        # for i in range(le):

        #     flag = 0

        #     for j in range(0,le-i-1):

        #         if nums[j+1] < nums[j]:

        #             tmp = nums[j+1]

        #             nums[j+1] = nums[j]

        #             nums[j] = tmp

        #             flag = 1

        #     if flag == 0:

        #         break

        # return nums[le-k]

 

        def portition(self,nums,start,end):

            tmp = nums[start]

            while start < end:

                while end > start and nums[end] >= tmp:

                    end -= 1     

                if end > start:

                    nums[start] = nums[end]

                    start += 1

                while end > start and nums[start] < tmp :

                    start += 1

                    

                if end > start: 

                    nums[end] = nums[start] 

                    end -= 1

            nums[start] = tmp

            return start

        def quickSort(self,nums,start,end):

            # start,end =0,len(nums)-1

            if start > end:

                return 

            p = portition(self,nums,start,end)

            quickSort(self,nums,start,p-1)

            quickSort(self,nums,p+1,end)

        quickSort(self,nums,0,le-1)

        return nums[le-k]