DataStructureAndAlgorithm--第 K 个最大值

设有一组 N 个数而要确定其中第 K 个最大者，我们称之为选择问题(selection problem)。

该问题的一种解法就是将这 N 个数读进一个数组中，再通过某种简单的算法，比如冒泡排序法，以递减顺序将数组排序，然后返回位置 K 上的元素。

稍微好一点的算法可以先把前 K 个元素读入数组并(以递减的顺序)对其排序。接着，将剩下的元素再逐个读入。当新元素被读到时，如果它小于数组中的第 K 个元素则忽略之，否则就将其放到数组中正确的位置上，同时将数组中的一个元素挤出数组。当算法终止时，位于第 K 个位置上的元素作为答案返回。

 package c1.kmax;

 import java.util.Arrays;

 /**
  * 一组 N 个数确定其中第 K 个最大者
  *
  * @author MicroCat
  *
  */
 public class KMax {

     public static void main(String[] args) {
         try {
             int[] arr = { 12, 4, 6, 3, 4, 5, 0, -8 };
             int[] arr2 = { 12, 4, 6, 3, 4, 5, 0, -8 };
             int k = 5;
             System.out.println("The " + k + " largest in arrays : " + kmax1(arr, k));
             System.out.println("The " + k + " largest in arrays : " + kmax2(arr2, k));
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

     /**
      * 读入 K 个元素至新数组，以递减方式储存。 将剩下的元素再逐个读入。若小于新数组的最小值，跳过；否则，替换新数组最末位元素，重新排序。
      * 最后返回新数组最末位元素。
      *
      * @param arr
      * @param k
      * @return
      * @throws Exception
      */
     public static int kmax2(int[] arr, int k) throws Exception {
         try {
             if (k <= 0 || k > arr.length) {
                 throw new Exception("k value out of range!");
             }
             int[] karr = new int[k];
             System.arraycopy(arr, 0, karr, 0, k);
             BubbleMaxToMin(karr);
             for (int i = k; i < arr.length; i++) {
                 if (arr[i] <= karr[k - 1]) {
                     // print
                     System.out.println("circle" + (i - k + 1) + " : " + Arrays.toString(karr));
                     continue;
                 } else {
                     karr[k - 1] = arr[i];
                     BubbleMaxToMin(karr);
                     // print
                     System.out.println("circle" + (i - k + 1) + " : " + Arrays.toString(karr));
                 }
             }
             System.out.println(Arrays.toString(karr));
             return karr[k - 1];
         } catch (Exception e) {
             // TODO: handle exception
             throw e;
         }
     }

     /**
      * 冒泡法由大到小排序
      *
      * @param karr
      */
     private static void BubbleMaxToMin(int[] karr) {
         for (int i = 0; i < karr.length; i++) {
             for (int j = karr.length - 1; j > i; j--) {
                 if (karr[j] > karr[j - 1]) {
                     karr[j] = karr[j] ^ karr[j - 1];
                     karr[j - 1] = karr[j] ^ karr[j - 1];
                     karr[j] = karr[j] ^ karr[j - 1];
                 }
             }
         }
     }

     /**
      * 冒泡法排序直接返回第 K-1 元素
      *
      * @param arr
      * @param k
      * @return
      * @throws Exception
      */
     public static int kmax1(int[] arr, int k) throws Exception {
         try {
             if (k <= 0 || k > arr.length) {
                 throw new Exception("k value out of range!");
             }
             BubbleMaxToMin(arr);
             System.out.println(Arrays.toString(arr));
             return arr[k - 1];
         } catch (Exception e) {
             // TODO: handle exception
             throw e;
         }

     }

 }