现象：

基础算法-分治算法-学习

分而治之，将复杂问题分成小问题，小问题直接求解，最后合并得到最终结果，
和递归思想有点相近，也是区分小问题自己解决，所以在分治算法很多以递归的方式实现
每个递归就是等于分成一个小问题去解决

通用案例：

一：汉诺塔问题

现在有三根柱子 A、B、C
* A柱子有从小到大N个盘子
* 现在要借助B柱子 将A柱子所有盘子移动到C柱子
* 条件：1-每次只能移动一个盘子、2-大盘子绝对不能放在小盘子上面
* 求移动盘子的次数

解决思路：
每次将问题分治
* 如果A塔上有多个盘分三步治理
* 第一步：将A柱子除最后一个盘所有盘移动到B柱子，
* 第二步：将A柱子最后一个盘移动到C柱子，
* 第三步：最后将B柱子的所有盘移动到C柱子
*
* 第一步和第三步又判断是不是多盘 是多盘则继续分上三步走（递归调用） 第二步单盘操作不需要递归

结果展示:

当A柱子有三个盘子的移动操作

当A柱子有五个盘的操作

代码方法：

   public static void main(String[] args) {
       var i = partitionAlgorithm(5, "A", "B", "C");
       log.debug("总移动步骤：{}",i);
   }



  public static int partitionAlgorithm(int num, String one, String two, String three) {
        // 盘子数量=1  不借助中间柱子 直接从A柱子移动到C柱子 一步完成
        if (num == 1) {
            log.debug("将第{}个盘子从{}柱子移动到{}柱子",num, one, three);
            return 1;
        } else {
            /**
             * 盘子数量大于1
             * 需要借助中间的柱子来移动
             * 第一步 先将a柱子移动到B柱子
             * 第二步 将a柱子移动到c柱子
             * 第三步 将b柱子移动到c柱子
             */
            var s1 = partitionAlgorithm(num - 1, one, three, two);
            log.debug("将第{}个盘子从{}柱子移动到{}柱子",num, one, three);
            var s3 = partitionAlgorithm(num - 1, two, one, three);
            return s1+s3+1;
        }
    }

通用案例：

快速排序
分治思想的排序操作
给定一个数组用分治思想实现快速排序

 * 解答思路：
 * 第一步：在数组中选一个基础值一般就是第一个值
 * 第二步：遍历此数组将大于基础值的放右边、小于基础值的放左边
 *  对左边和右边的值 在分别递归第一步和第二步操作 直到剩下一个值为止

快速排序双指针方式步骤：

• 第一步：选定数组中第一个值作为基数
• 第二步：指定两个指针一个从最左开始，一个从最右开始
• 第三步：循环 右指针值与基数值判断
  • 如果比基数大就 右指针左移 如果比基数小则停止
• 第四步：循环 左指针与基数值判断
  • 如果比基数小就 左指针右移 如果比基数大则停止
• 第五步：左右指针都停止了
  • 此时右边指针对应的值小于基数
  • 左指针对应的值大于基数
  • 调换两个基数的值
• 第六步：循环 三、四、五步 直到指针在中间相遇

  •  此时这个相遇位置就是基数的正确位置
    

  •  右边都大于基数
    

  •  左边都小于基数
    

• 第七步：调转基数和指针相遇位置,使基数到达自己的正确位置
• 第八步：将基数左边的子数组 递归调用，将基数右边的子数组也递归调用

调用结果：

代码方法：

    public static void main(String[] args) {
        int[] a={8,2,6,5,9,1,7,4};
        quickSort(a,0,a.length-1);

        for (int i=0;i<a.length-1;i++){
            System.out.printf("---"+a[i]);
        }
    }



   /**
     * 快速排序
     * 分治思想的排序操作
     * 给定一个数组用分治思想实现快速排序
     *
     * 解答思路：
     * 第一步：在数组中选一个基础值一般就是第一个值
     * 第二步：遍历此数组将大于基础值的放右边、小于基础值的放左边
     *      对左边和右边的值 在分别递归第一步和第二步操作 直到剩下一个值为止
     *
     *  快速排序双指针方式步骤：
     *  第一步：选定数组中第一个值作为基数
     *  第二步：指定两个指针一个从最左开始，一个从最右开始
     *  第三步：循环 右指针值与基数值判断
     *      如果比基数大就 右指针左移   如果比基数小则停止
     *  第四步：循环 左指针与基数值判断
     *      如果比基数小就 左指针右移  如果比基数大则停止
     *  第五步：左右指针都停止了
     *      此时右边指针对应的值小于基数
     *      左指针对应的值大于基数
     *      调换两个基数的值
     *  第六步：循环 三、四、五步 直到指针在中间相遇
     *      此时这个相遇位置就是基数的正确位置
     *      右边都大于基数
     *      左边都小于基数
     *  第七步：调转基数和指针相遇位置,使基数到达自己的正确位置
     *  第八步：将基数左边的子数组 递归调用，将基数右边的子数组也递归调用
     */
    public static void quickSort(int[] ints,int start,int end) {
        if(start < end){
            // 第一步:第一个元素 作为基数
            var startInt = ints[start];
            // 第二步：第一个值和最后一个值的基础状态作为左右指针
            int left = start;
            int right = end;

            // 左指针小于右指针作为循环条件   每次两个指针相遇则跳出循环
            while (left < right){
                // 对应第三步  循环 右指针值与基数值判断
                while (ints[right] >= startInt && left < right){
                    right--;
                }
                // 对应第四步  循环 左指针与基数值判断
                while (ints[left] <= startInt && left < right){
                    left++;
                }
                // 对应第五步  左右指针都停止了  此时右指针的值大于基数  左指针的值小于基数 调换指针数值
                if(left < right){
                    int temp = ints[left];
                    ints[left] = ints[right];
                    ints[right] = temp;
                }
            }
            // 对应第七步  跳出了循环 说明第一轮已经结束 次数指针已经交汇在一起  指针交汇位置就是基数的正确位置 将基数与指针交汇处转换数值
            int temp = ints[left];
            ints[left] = ints[start];
            ints[start] = temp;

            // 对应第八步：递归左边的子数组
            quickSort(ints,start,left-1);
            // 对应第八步：递归右边的子数组
            quickSort(ints,left+1,end);
        }
    }