在数组中找到第k大的元素

题目描述：

在数组中找到第k大的元素，可以交换数组中的元素的位置

样例

给出数组 [9,3,2,4,8]，第三大的元素是 4

给出数组 [1,2,3,4,5]，第一大的元素是 5，第二大的元素是 4，第三大的元素是 3，以此类推

挑战

要求时间复杂度为O(n)，空间复杂度为O(1)

代码实现：

class Solution:
    """
    @param n: An integer
    @param nums: An array
    @return: the Kth largest element
    """
    '''
    #超时
    #第一种  快排程序---返回第k大的值，逆序排返回下标为k-1的
    def quickSort(self,nums,left,right,k):
        i=left
        j=right
        base=nums[i]
        while i<j:
            while i<j and nums[j]<=base:
                j-=1
            if i<j:
                nums[i]=nums[j]
                i+=1
            while i<j and nums[i]>=base:
                i+=1
            if i<j:
                nums[j]=nums[i]
                j-=1
        nums[i]=base
        if i==k-1:
            return nums[i]
        elif i<k-1:
            return self.quickSort(nums,i+1,right,k)
        else:
            return self.quickSort(nums,left,i-1,k)
            
    def kthLargestElement(self, n, nums):
        # write your code here
        return self.quickSort(nums,0,len(nums)-1,n)
    '''
    '''
    #第二种，直接调用自带的排序函数
    def kthLargestElement(self,n,nums):
        sortedArray=sorted(nums,reverse=True)
        return sortedArray[n-1]
    '''
    
    #第三种 
    def quickSort(self,nums,left,right):
        i=left
        j=right
        base=nums[i]
        while i<j:
            while i<j and nums[j]<=base:
                j-=1
            if i<j:
                nums[i]=nums[j]
                i+=1
            while i<j and nums[i]>=base:
                i+=1
            if i<j:
                nums[j]=nums[i]
                j-=1
        nums[i]=base
        return i
                     
    def kthLargestElement(self,n,nums):
        '''
        #错误示例
        index=self.quickSort(nums,0,len(nums)-1)
        if index==n-1:
            return nums[index]
        elif index<=n-1:
            return nums[self.quickSort(nums,index+1,len(nums)-1)]#quickSort返回值可能并不是n-1,所以此处不能递归调用
        else:
            return nums[self.quickSort(nums,0,index-1)]
        '''

        left=0
        right=len(nums)-1
        index=-3
        while index!=n-1:
            index=self.quickSort(nums,left,right)
            if index<n-1:
                left=index+1
            elif index>n-1:
                right=index-1
        return nums[index]

思路：

主要想应用快速排序来对整个数组排序（逆序），然后直接返回第k大的值，即数组下标为k-1的元素。但是结果超时，只有80%的数据测试正确。当直接应用sorted函数时，结果正确。

鉴于快排超时，又在百度上找到另一种快排的实现，如下：

import random 
class Solution: 
    def kthLargestElement(self, k, A): 
        middle = random.randint(0, len(A)-1) 
        A_big = [] 
        A_small = [] 
        num = 0 
        for index in range(0, len(A)): 
            if(A[index]>A[middle]): 
                A_big.append(A[index]) 
            elif(A[index]==A[middle]): 
                num=num+1 
            elif(A[index]<A[middle]): 
                A_small.append(A[index]) 
        if(len(A_big)==k-1): 
            return A[middle] 
        elif(len(A_big)>k-1): 
            return self.kthLargestElement(k, A_big) 
        elif(len(A_big)<k-1):
            return self.kthLargestElement(k-len(A_big)-num, A_small)