查找N个数中第K大的数

方法一：将一组数放入数组中，升排序。并返回第 ( length - k )个元素
这里消耗的时间就是排序用的时间，用快速排序则为：O( N log N )

代码：

	/**
	 * 先排序后获取
	 * @return
	 *
	 * Date	  :2012-7-4
	 * Author :GongQiang
	 */
	public int sortThenGet( int k ){
		Collections.sort( list );
		return list.get( list.size() - k );
	}

方法二：构造一个 K 长度的数组，将前K位数复制过来并排序（降序）。然后依次将 K+1 到 N 位的数比较并插入 K 长度的数组中。返回最后一个即可。

这时间度为：O( N*K ) 如果 K = N/2  则复杂度为 O( N*N )

代码：

	/**
	 * 先取出前K个数排序，再从后面依次插入
	 * @param k
	 * @return
	 *
	 * Date	  :2012-7-4
	 * Author :GongQiang
	 */
	public int kSortThenCompare( int k ){
		List<Integer> result = new ArrayList<Integer>( k );
		for( int i=0 ; i<k ; i++ ){
			result.add( list.get(i) );
		}
		
		//前K位数，按照从大到小排序
		Collections.sort( result, new Comparator<Integer>(){
			public int compare(Integer o1, Integer o2) {
				if( o1 > o2 ){
					return -1;
				}
				if( o1< o2 ){
					return 1;
				}
				return 0;
			}
		});
		
		// 后 K+1 位数与前面的有序数组比较，插入适当的位置
		for( int i=k ; i<list.size() ; i++ ){
			int j = k-1;
			while( j>=0 && list.get(i) > result.get(j) ){
				j--;
			}
			
			if( 0<=j && j<k-1 && list.get(i) < result.get(j) ){
				result.add( j+1, list.get(i) );
			}
			else if( j==-1 ){ //结束条件是 j==-1
				result.add( 0, list.get(i) );
			}
		}
		
		return result.get( k-1 );
	}

方法三：将 N 个数构造成一个“大堆”，然后删除堆的根 K 次，最后一次即为结果。

 构造堆的最坏用时：O( N )

每次删除根用时：O( log N )

则中的运行时间为： O( N + k*log N )

如果 K = O(  N/ log N ) ，则总共用时就是构造堆的时间，即 O( N )

如果 K 很大，则总时间为 O( K* log N)

如果 K = N/2，则总时间为Θ( N*log N )

代码：

	/**
	 * 先构建一个堆，然后获取
	 * @param k
	 * @return
	 *
	 * Date	  :2012-7-4
	 * Author :GongQiang
	 */
	public int buildHeapThenGet( int k ){
		PriorityQueue<Integer> heapQueue = new PriorityQueue<Integer>( NUMBER_COUNT, 
			new Comparator<Integer>(){ //这里是取第K大的元素，因而要改变排序规则
			public int compare(Integer o1, Integer o2) {
				if( o1 > o2 ){
					return -1;
				}
				if( o1< o2 ){
					return 1;
				}
				return 0;
			}
			
		});
		for( int i=0 ; i<list.size() ; i++ ){
			heapQueue.add( list.get(i) );
		}
		
		int result=0;
		for( int i=0 ; i<k ; i++ ){
			result = heapQueue.remove();
		}
		return result;
	}

方法四：思路和方法二一样，只不过用堆来实现。

构造堆的时间：O( K )

处理每个其余元素的时间：O( 1 )

检测是否进入堆的时间：O( log K )

总时间：O( K + (N-K)*log K ) = O( N* log K )

该算法找出中位数的时间界面：Θ( N*log N )

注意：这里使用优先队列提供的堆来操作，这样

检测的时间为O( log K )

删除的时间为O( log K )

插入的时间为O( log K )

所以，这里的代码时间复杂度比单纯在堆上操作要多很多。

代码：

	/**
	 * 前K个数构造一个堆，然后进行比较插入
	 * @param k
	 * @return
	 *
	 * Date	  :2012-7-4
	 * Author :GongQiang
	 */
	public int heapOfFistKThenSert( int k ){
		PriorityQueue<Integer> heapQueue = new PriorityQueue<Integer>( k );
		for( int i=0 ; i<k ; i++ ){
			heapQueue.add( list.get(i) );
		}
		
		for( int j = k ; j<list.size() ; j++ ){
			int queueLength = k;
			int flag = 0;
			while( queueLength >0 ){
				if( heapQueue.peek() < list.get(j) ){
					flag =1;
					break;
				}
				
				queueLength--;
			}
			
			if( flag == 1 ){
				heapQueue.poll();
				heapQueue.offer( list.get(j) );
			}
			
		}
		
		return heapQueue.peek();
	}

四种算法在 10 万个数值中，查找第100大，1000大，10000大实际用时

先排序在获取：
用时间：69547064, 100大数:99903985
用时间：64447309, 1000大数:98963233
用时间：63601693, 10000大数:89862625

先排序前K个数，然后插入，最后获取：
用时间：14299865, 100大数:99903985
用时间：94025432, 1000大数:98963233
用时间：4053122244, 10000大数:89857698

先构建一个堆，然后获取：
用时间：29191262, 100大数:99903985
用时间：11743673, 1000大数:98963233
用时间：21491442, 10000大数:89862625

先构建一个堆(前K个数)，依次比较插入，最后获取：
用时间：199040953, 100大数:99903985
用时间：1786736869, 1000大数:98963233
用时间：11739682175, 10000大数:89862625

可以看出，方法三最优。

方法五：随机选择（参考快速排序的思想）

	/**
	 * 随机选择
	 * @param list
	 * @param start
	 * @param end
	 * @param i
	 * @return
	 *
	 * Date	  :2012-10-25
	 * Author :GongQiang
	 */
	int randomSelect( List<Integer> list, int start, int end, int i ){
		if( start == end ){
			return list.get(start);
		}
		
		int q = randomPartition(list, start, end);
		int k = end - q + 1;
		if( i == k ){
			return list.get( q );
		}
		else if( i<k ){
			return randomSelect(list, q+1, end, i);
		}
		else{
			return randomSelect(list, start, q-1, i-k);
		}
	}
	
	private int randomPartition( List<Integer> list, int start, int end ){
		int i = (int)(random.nextFloat()*( end-start )) + start;
		swap( list, i, end );
		
		return partition(list, start, end);
	}
	
	private int partition( List<Integer> list, int start, int end ){
		int temp = list.get(end);
		int i = start - 1;
		for( int j=start; j<end; j++ ){
			if( list.get(j) <= temp ){
				i++;
				swap( list, i, j);
			}
		}
		swap( list, i+1, end);
		return i+1;
	}
	
	private void swap( List<Integer> list, int i, int j ){
		int temp = list.get(i);
		list.set(i, list.get(j));
		list.set(j, temp);
	}

运行性能比较（一百万中查询）：

先排序在获取：
用时间：1073446509, 100大数:99991468
用时间：1086298487, 1000大数:99897550
用时间：995448554, 10000大数:98988059
用时间：996302124, 550000大数:45011888

先构建一个堆，然后获取：
用时间：98659237, 100大数:99991468
用时间：92088339, 1000大数:99897550
用时间：114273553, 10000大数:98988059
用时间：1590825451, 550000大数:45011888

随机选择
用时间：113330378, 100大数:99991468
用时间：121606562, 1000大数:99897550
用时间：123834509, 10000大数:98988059
用时间：231643029, 550000大数:45011888

可以看出，【随机选择】性能很稳定，而且较优！