递归

    public static void main(String[] args) {
        int[] arr = new int[]{11,2,4,7,3,2,3,134,78,99};
        quickSort(arr,arr.length);
       for(int i = 0;i<arr.length;i++){
           System.out.println(arr[i]);
       }

    }

    /**
     *
     * @param n 数组的大小
     */
    private static void mergeSort(int[] arr,int n){
        mergeSortInternally(arr,0 ,n-1);

    }

    private static void mergeSortInternally(int[] arr, int begin,int end) {
        //递归结束条件
        if(begin >= end){
            return;
        }
        int mid = (end+begin)/2;
        mergeSortInternally(arr,begin,mid);
        mergeSortInternally(arr,mid+1,end);
        merge(arr,begin,mid,end);
    }

    /**
     * 合并两个有序数组
     * @param arr
     * @param begin
     * @param mid
     * @param end
     */
    private static void merge(int[] arr, int begin, int mid, int end) {
        int[] result = new int[end-begin+1];
        int arr1Start = begin;
        int mark = mid+1;
        int i= 0;
        while(arr1Start<=mid && mark<=end){
            if(arr[arr1Start]<arr[mark]){
                result[i++] = arr[arr1Start++];
            }else{
                result[i++]=arr[mark++];
            }
        }
        //先假设arr1 没有把数据拿出来完
        int resultStart = arr1Start;
        int resultEnd = mid;

        if(mark<=end){
            resultStart = mark;
            resultEnd = end;
        }

        while(resultStart<=resultEnd){
            result[i++]=arr[resultStart++];
        }
        for (int j=0;j < result.length;j++){
            arr[begin+j] = result[j];
        }
    }

    private static void quickSort(int[] arr,int n){
        quickSortInternally(arr,0,n-1);
    }

    private static void quickSortInternally(int[] arr, int begin, int end) {
        if(begin>=end){
            return;
        }

        int partition = partition(arr,begin,end);

        quickSortInternally(arr,begin,partition-1);
        quickSortInternally(arr,partition+1,end);
    }

    /**
     * 快速排序的分区选择是重点，有很多种 三数取中法，随机法
     * 这里选择的是最简单的一种选择最后一个元素进行分区
     * @param arr
     * @param begin
     * @param end
     * @return
     */
    private static int partition(int[] arr, int begin, int end) {
        int  i = begin;
        int j = begin;
        int partitionData = arr[end];
       for(;i<end;i++){
           if(arr[i] < partitionData){
                  //交换操作
                  int temp = arr[i];
                  arr[i] = arr[j];
                  arr[j] = temp;
                  j++;
           }
       }
        int temp = arr[j];
        arr[j] = partitionData;
        arr[end] =temp;
        return j;
    }
    
    
     //1.保存齐王的马匹
    private static Map<String,Double>  q_house_score = new HashMap<String, Double>(){
        {
            put("q1", 1.0);
            put("q2", 2.0);
            put("q3", 3.0);
        }
    };


    // 2.设置田忌的马跑完所需时间
    public static HashMap<String, Double> t_house_score = new HashMap<String, Double>(){
        {
            put("t1", 1.5);
            put("t2", 2.5);
            put("t3", 3.5);
        }
    };

    private static ArrayList<String>  q_houses = new ArrayList<String>(Arrays.asList("q1","q2","q3"));

    /**
     * 求出所有的排列
     * @param houses
     * @param result
     */
    private static void permutate(ArrayList<String> houses,ArrayList<String> result){
        if(houses.size()<=0){
            System.out.println(result);
            compute(result,q_houses);
            return;
        }else{
            for(int i= 0;i<houses.size();i++){
                ArrayList<String> newResult  = (ArrayList<String>) result.clone();
                ArrayList<String> newHouses  = (ArrayList<String>) houses.clone();
                newResult.add(newHouses.remove(i));
                permutate(houses,newResult);
            }
        }
    }

    private static void compute(ArrayList<String> result, ArrayList<String> q_houses) {
    }



    /**
     * @Description:	使用函数的递归（嵌套）调用，找出所有可能的队伍组合
     * @param teams- 目前还剩多少队伍没有参与组合，result- 保存当前已经组合的队伍
     * @return void
     */

    public static void combine(ArrayList<String> teams, ArrayList<String> result, int m) {

        // 挑选完了 m 个元素，输出结果
        if (result.size() == m) {
            System.out.println(result);
            return;
        }

        for (int i = 0; i < teams.size(); i++) {
            // 从剩下的队伍中，选择一队，加入结果
            ArrayList<String> newResult = (ArrayList<String>)(result.clone());
            newResult.add(teams.get(i));

            // 只考虑当前选择之后的所有队伍
            ArrayList<String> rest_teams = new ArrayList<String>(teams.subList(i + 1, teams.size()));

            // 递归调用，对于剩余的队伍继续生成组合
            combine(rest_teams, newResult, m);
        }

    }

    public static void main(String[] args) {

        ArrayList<String> teams = new ArrayList<String>(Arrays.asList("t1", "t2", "t3"));
        combine(teams, new ArrayList<String>(), 2);

    }