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;
        }

    }

}