组合算法（类似C(5,2)）

/**
 *  get combinations ( C(superscript, subscript) )
 * @param totalCount  normal data node group count except primary data node group
 * @param selectCount    secondary data node count
 * @return  the possibility of combinations
 *  e.g. the possibility of select 2 members from 5 members
 *  the possibility: {[5,4], [5,3], [5,2], [5,1], [4,3], [4,2], [4,1], [3,2], [3,1], [2,1]}
 */
private List<Deque<Integer>> getCombination(int totalCount, int selectCount){
    //The combination of secondary count from group Count which expect primary group .
    int comb[] = new int[selectCount+1];
    comb[0] = selectCount;

    List<Deque<Integer>> resultIndexList = new ArrayList<>();
    combination(comb, totalCount, selectCount, resultIndexList);

    logger.info("secondary group index combination:{}", resultIndexList);
    return resultIndexList;
}

/**
 *  get combinations( C(superscript, subscript) )
 *  e.g. C(5, 2) ,the resultList: {[5,4], [5,3], [5,2], [5,1], [4,3], [4,2], [4,1], [3,2], [3,1], [2,1]}
 * @param comb          last result of combination
 * @param superscript   max of the number
 * @param subscript     select numbers count
 * @param resultList result after combination
 */
private void combination(int comb[], int superscript, int subscript, List<Deque<Integer>> resultList) {
    for (int i = superscript; i >= subscript; i--) {
        // select current head element
        comb[subscript] = i;

        if (subscript > 1) {
            // enter next smaller combination
            combination(comb, i-1, subscript-1, resultList);
        } else {
            Deque<Integer> selectIndexQueue = new ArrayDeque<>();
            // save combination
            for (int j=comb[0]; j>0; j--) {
                selectIndexQueue.add(comb[j]);
            }
            resultList.add(selectIndexQueue);
        }
    }
    return;
}