【LeetCode】215. Kth Largest Element in an Array，基于Java和C++的解法

215. Kth Largest Element in an Array

Total Accepted: 57859 Total Submissions: 171725 Difficulty: Medium

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

For example,
Given [3,2,1,5,6,4] and k = 2, return 5.

Note: 
You may assume k is always valid, 1 ≤ k ≤ array's length.

【Section one】分析

题意：输入一个未排序的数组，寻找第K大的数并返回。初见之下，这个题似乎比较简单，但实际操作中遇到一些有趣的问题：

      1、采用Java，Accepted的算法，用C++实现出现了内存超限（Memory Limit Exceed）；

      2、Java和C++不同的内存管理模式；

分析：

     寻找数组中第K大的数据，一个直观的思路是将数组排序，然后直接通过索引返回第K大的数据。这样做完全可以实现，但是明显做了很多无用功，由于我们只需寻找第K大的数，完全没有必要进行全排序。在所有基本的排序算法中，快速排序是一种比较优秀的算法，平均时间复杂度O(nlogn)，在排序中用到的一个重要思想：分治！每一次partition时，返回的都是分割后作为“轴”的元素的下标，其左边的元素均小于等于它，其右边的元素均大于它，因此，经过分割后，若“轴”元素在数组中的下标为p,则“轴”元素为第lengthOfArray-p大的元素；基于这种思想我们可以很快写出两种风格的程序。

【Section two】

基于Java语言的解法一：

class Solution {
    public int findKthLargest(int[] nums, int k) 
    {
    	return quickSort(0,nums.length-1,nums,k);        
    }
    
    int quickSort(int low,int high,int[] temp,int k)
    {
    	if(low>=high)return temp[low];//递归结束的约束条件
    	int point=partition(low,high,temp);//每一次分割后“轴”的下标
    	
    	if(temp.length-point==k) return temp[point];
    	else if(temp.length-point>k){
    		return quickSort(point+1,high,temp,k);
    	}
    	else{
    		return quickSort(low,point-1,temp,k);
    	}
    }
    
    public int partition(int low,int high,int[] temp)//采用分治的思想
    {
    	int cur=temp[low];
    	while(low<high)
    	{
    		while(low<high&&temp[high]>=cur)
    			--high;
    		temp[low]=temp[high];
    		while(low<high&&temp[low]<=cur)
    			++low;
    		temp[high]=temp[low];
    	}
    	temp[low]=cur;
    	return low;
    }
}

基于Java的解法二：

   这个解法与解法一相比，都是“分治”的思想，但是，解法二中却消耗了大量的内存！！！！，随着递归的进行，每一层都需要分配内存用于存储子数组，且此题给定的形参为int[]，而根据需要我们定义的是具有动态增删功能的数组列表，在递归调用的时候，还需要复杂的转化，这也会造成时间和空间的消耗。

class Solution2 {
    public int findKthLargest(int[] nums, int k) 
    {
        List<Integer> leftarray=new ArrayList<Integer>();
        List<Integer> rightarray=new ArrayList<Integer>();//定义两个数组列表存储分割后的数组
       
        for(int i=1;i<nums.length;i++)
        {
            if(nums[i]<=nums[0])//以第一个元素为轴，将数组分成两个子数组
            {
            	leftarray.add(nums[i]);//左数组为小于等于转轴的元素
            }
            else
            {
            	rightarray.add(nums[i]);
            }
        }
        
        if(rightarray.size()>=k)//此情况下，第k大的元素必然存在于右子树组
        {
        	int[] rightRemain=new int[rightarray.size()];
        	int i=0;
        	for(Integer e:rightarray)//由于给定的方法的形参列表为int[]，这里需要转换一下
        		rightRemain[i++]=e;
        	return findKthLargest(rightRemain, k);
        }
        else if(rightarray.size()==k-1)
        {
        	return nums[0];
        }
        else
        {
        	int[] leftRemain=new int[leftarray.size()];
        	int i=0;
        	for(Integer e:leftarray)
        		leftRemain[i++]=e;
        	return findKthLargest(leftRemain, k-rightarray.size()-1);
        }
       
    }
}

</pre><p></p><pre>

基于C++的解法：

     如下为基于C++的解法，和基于Java的解法二完全相同，看上去程序更为简洁，但是，在LeetCode平台上会出现内存超限（Memory Limit Exceeded）的问题，这与C++中内存的管理模式有关：vector其中一个特点：内存空间只会增长，不会减小，援引C++ Primer：为了支持快速的随机访问，vector容器的元素以连续方式存放，每一个元素都紧挨着前一个元素存储。设想一下，当vector添加一个元素时，为了满足连续存放这个特性，都需要重新分配空间、拷贝元素、撤销旧空间，这样性能难以接受。因此STL实现者在对vector进行内存分配时，其实际分配的容量要比当前所需的空间多一些。就是说，vector容器预留了一些额外的存储区，用于存放新添加的元素，这样就不必为每个新元素重新分配整个容器的内存空间。

    同时，vector的clear()方法只能清除vector中的元素却无法释放其占用内存，一般通过vector<int>().swap(p)来释放。swap()是交换函数，使vector离开其自身的作用域，从而强制释放vector所占的内存空间。

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k)
    {
        vector<int> leftArray;
        vector<int> rightArray;
        
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]<=nums[0])
            leftArray.push_back(nums[i]);
            else
            rightArray.push_back(nums[i]);
        }
        
        if(rightArray.size()>=k)
        {
            vector<int>(leftArray).swap(leftArray);
            return findKthLargest(rightArray, k);
        }
        else if(rightArray.size()==k-1)
        {
            return nums[0];
        }
        else
        {
            int len=k-rightArray.size()-1;
            vector<int>().swap(rightArray);
            return findKthLargest(leftArray, len);
        }
    }
};