摘要：一個面試題一個數組找出這樣的三個元素它們的和與目標值最接近如原始數組目標值這樣的三個元素算法沒有想到什么好的算法可以快捷的找到這樣的三個元素只想到了窮舉法即找出所有的任意三元素數組長度放到優先隊列中按三個元素的和與目標值的差值絕對值進行排序

一個面試題

一個數組 找出這樣的三個元素 它們的和與目標值最接近
如
原始數組： [15, 27, 31, 33, 39, 44, 50, 57, 86, 91]
目標值: 98
這樣的三個元素：15,33,50 （15+33+50=98）

沒有想到什么好的算法 可以快捷的找到這樣的三個元素
只想到了窮舉法 即

找出所有的任意三元素 C(數組長度,3)

放到優先隊列中 按三個元素的和與目標值的差值（絕對值）進行排序

第一個即是與目標值最接近的三元素

// 得到所有的三元素組合列表 如["1,2,3", "4,5,6" , ...]
List allUniqueThreeElements = getAllUniqueThreeElements(a,3);

// 三元素列表轉成對象  對象中提供了這樣的方法：getDiff (計算三元素的和與目標值的差值（絕對值）)
List threeElementsList = new ArrayList<>();
for (String s : allUniqueThreeElements) {
    elementsList.add(new ThreeElements(s));
}
// 構造優先隊列 按三元素的和與目標值的差值（絕對值）進行排序 優先隊列默認大小為三元素組合列表大小
PriorityQueue pq = new PriorityQueue<>(threeElementsList.size(),comparingInt(o -> o.getDiff(target))); 

// 將三元素組合對象 逐一放到優先隊列中
for (ThreeElements e : threeElementsList) {
    pq.offer(e);
}

ThreeElements poll = pq.poll(); // 優先隊列中 第一個即為要找的三元素

即C(n,m)

如 數組 [1,2,3,4,5] 找出所有的三元素組合

相當于將同一數組復制三份 每一份中 取一個元素 不重復即可

這樣的取法

    /**
     * 
     * @param indexArray 索引數組
     * @param maxIndexValue 最大索引值
     * @param startIndex indexArray中從此位開始遞增
     * @return
     */
    private boolean next(final int[] indexArray, final int maxIndexValue, int startIndex){
//        System.out.println("indexArray: "+Arrays.toString(indexArray));
//        System.out.println("startIndex: "+startIndex);
        indexArray[startIndex]++; // 從此位開始遞增
        if(indexArray[startIndex] > maxIndexValue){ // 超過最大索引值 從前一位開始遞增
            return next(indexArray,maxIndexValue,startIndex-1);
        }else{
            // 同時逐個累加之后的元素 后一位的值 = 前一位+1
            for (int i = startIndex+1; i < indexArray.length; i++) {
                indexArray[i] = indexArray[i-1]+1;
                if(indexArray[i] > maxIndexValue){
                    if(startIndex -1 < 0){ // 如果是從第一位開始遞增的 即不存在更前一位了 則退出遞歸
                        return false;
                    }
                    return next(indexArray,maxIndexValue,startIndex-1);
                }
            }
            return true;
        }
    }

測試代碼

    @Test
    public void test_next(){
        // 測試從一個數組中得到所有的三元素組合
        int[] a = {1, 2, 3, 4, 5}; // 數組
        int maxIndexValue = a.length-1; // 最大索引值
        int[] indexArray = {0,1,2}; // 初始化索引數組
        int startIndex = indexArray.length-1; // 從末位開始遞增

        // 驗證  [0,1,2] --> [0,1,3]
        boolean next = next(indexArray, maxIndexValue, startIndex);
        assertTrue(next);
        assertArrayEquals(new int[]{0,1,3}, indexArray);

        // 驗證 [0,1,4] --> [0,2,3]
        indexArray = new int[]{0, 1, 4};
        next = next(indexArray, maxIndexValue, startIndex);
        assertTrue(next);
        assertArrayEquals(new int[]{0,2,3}, indexArray);

        // 驗證 [0,3,4] --> [1,2,3]
        indexArray = new int[]{0, 3, 4};
        next = next(indexArray, maxIndexValue, startIndex);
        assertTrue(next);
        assertArrayEquals(new int[]{1,2,3}, indexArray);

        // 驗證 [2,3,4] --> X
        indexArray = new int[]{2, 3, 4};
        next = next(indexArray, maxIndexValue, startIndex);
        assertFalse(next);
    }

當驗證其他一些極端情況的時候 如從一個數組中得到所有一個元素的組合 即C(n,1) 測試沒有通過

    @Test
    public void test_next_and_only_choose_one_element(){
        // 測試一些更極端的情況 如 一個數組中選出所有1個元素的組合(C(n,1))
        final int[] a = {1, 2, 3, 4, 5};
        int maxIndexValue = a.length-1;
        int[] indexArray = {0};
        int startIndex = indexArray.length-1;


        //驗證 [0] -> [1]
        boolean next = next(indexArray, maxIndexValue, startIndex);
        assertTrue(next);
        assertArrayEquals(new int[]{1},indexArray);
        System.out.println();
        // 驗證 [4] -> X
        indexArray = new int[]{4};
        next = next(indexArray, maxIndexValue, startIndex);
        assertFalse(next);
    }

修復代碼 將判斷最后沒有下一組的代碼給提取出來了

    private boolean next(final int[] indexArray, final int maxIndexValue, int startIndex){
        if(startIndex < 0){ // 如果不存在更前一位了 則退出遞歸
            return false;
        }
        indexArray[startIndex]++; // 從此位開始遞增
        if(indexArray[startIndex] > maxIndexValue){ // 超過最大索引值 從前一位開始遞增
            return next(indexArray,maxIndexValue,startIndex-1);
        }else{
            // 同時逐個累加之后的元素 后一位的值 = 前一位+1
            for (int i = startIndex+1; i < indexArray.length; i++) {
                indexArray[i] = indexArray[i-1]+1;
                if(indexArray[i] > maxIndexValue){
                    return next(indexArray,maxIndexValue,startIndex-1);
                }
            }
            return true;
        }
    }

http://wiki.jikexueyuan.com/p...