算法基础（Java）--分治算法

时间 2019-11-08

标签算法基础 java 分治栏目 Java 繁體版

原文原文链接

前言

此篇博客为转载和修改，来源写在参考资料。java

分治算法

分治,"分而治之"。从字面上理解就是分---治，把大的问题分红小问题，解决一个一个小问题，以后把问题的答案合并起来，就获得大问题的结果。您确定会在想，这思想这么简单，你不说我也是知道。历史上，秦国经过远交近攻的策略，逐个击破，最后统一六国不也是分治思想的体现吗？如下用一个二叉树的前序遍历为例，对分治思想在代码上的体现进行说明。node

public class PreoderTraversal {
    public class TreeNode{
        private int val;
        public TreeNode left,right;
        public TreeNode(int val){
            this.val = val;
            this.left = this.right = null;
        }
    }
    public ArrayList<Integer> preodertraversal(TreeNode root){
        ArrayList<Integer> result = new ArrayList<Integer>();
        //退出的条件
        if(root == null){
            return null;
        }
        //分：左子树与右子树
        ArrayList<Integer> left = preodertraversal(root.left);
        ArrayList<Integer> right = preodertraversal(root.right);

       //治：把获得的结果合并起来
        result.add(root.val);
        result.addAll(left);
        result.addAll(right);
        return result;
    }
}

上面的过程能够经过一个递推公式来表示
T(n) = 2T(2/n)+O(1)
2T(2/n) 表示 原来的大问题变成两个原来一半的问题
O(1)表示 对二叉树的每一个节点只操做一次。
上面的公式能够推出 上面前序遍历的时间复杂度是 O(n)

复制代码

从以上代码，能够看出，分治算法在代码实现上有如下两点好处： 1.前序遍历的结果可用经过一个函数内的ArrayList返回不须要建立全局变量，来存放结果。 2.对于拆分后的问题，运算量大，采用多并发，多核来处理，也是很容易的。具体结合上面代码来讲，对于left、right结果求解，能够分别启用一个线程。面试

两道题

对于分治的题目不少，为何选择下面这两道题目呢？由于足够典型，学会了这两道题，咱们保证，您在与同事、面试官聊起分治算法的时候，他们会认为您是懂分治算法。算法

接下来祭出第一道题目

分析：既然咱们使用分治来解决，那就看看问题怎么拆分呢？这道题目中是求两个节点的公共的祖先，很显然，问题的拆分能够依据：两个节点在二叉树的位置来拆分问题：都在左子树上、都在右子树上、一个边一个、有一个节点就是根节点bash

一个大的问题拆分四个问题，逐个解决，求出大问题，下面给出实现代码并发

public TreeNode getAncestor(TreeNode root,TreeNode node1,TreeNode node2){
        if (root == null)
        {
            return null;
        }
        //若是有一个节点就是根节点
        if(root == node1 || root == node2){
            return root;
        }

        TreeNode left = getAncestor(root.left,node1,node2);
        TreeNode right = getAncestor(root.right,node1,node2);
        //节点一边一个
        if(left == null && right == null)
        {
            return  root;
        }
       //节点都在左子树
        if (left != null) {
            return left;
        }
       //节点都在右子树
        if (right != null) {
            return right;
        }
        return null;
    }

复制代码

若是您还不太明白，不要紧，对着分析和代码多看几回，就会打通任督二脉的。函数

第二道（这道题，有点小难度）

为何说这道题有点难度呢？缘由在于二叉树上有负值的存在。并且最关键的是题目只是说遍历二叉树，求最大和，并无说是从哪里出发，若是从根出发就是求： root---->anyNode 根到任意节点的最大和明显这题目的意思是 anyNode---->anyNode 任意节点到任意节点的最大和。采用分治，怎么拆分呢？为三种状况：左子树、右子树、左子树-->根-->右子树。不明白，不要紧，看下图分析。分析：ui

代码实现this

public class returnType{
        int root2any,any2any;
        returnType(int root2any,int any2any){
            this.root2any = root2any;  //存放上面分析的root-->anyNode
            this.any2any = any2any;  // anyNode-->anyNode
        }
    }

 public returnType maxSum(TreeNode root){
       //若是二叉树不存在，直接设置成最小值
        if(root == null){
            return new returnType(Integer.MIN_VALUE,Integer.MIN_VALUE);
        }

        returnType left = maxSum(root.left);
        returnType right = maxSum(root.right);

        //结合上面的图就是求A+B大仍是A+C大呢，
       和0作比较就是由于有负数的存在
        int root2any =Math.max(0,Math.max(left.root2any,right.root2any))+root.val;

       //R=Math.max（D，E）
        int any2any = Math.max(left.any2any,right.any2any);

        //Math.max(R,A+B+C)
        any2any = Math.max(any2any,Math.max(0,left.root2any)+Math.max(0,right.root2any)+ root.val);

        return  new returnType(root2any,any2any);

    }

复制代码

小福利

分治算法其实在最初的快排和归并排序都接触过了，若是你上面两道题目都理解，下面给出归并排序和快排的代码在重温一下，看下感受是否是so easy！！归并排序spa

private static Comparable[] aux;
   public static void sort(Comparable[] list){
        aux = new Comparable[list.length];
        sort(list,0,list.length-1);
   }

    public static void sort(Comparable[] list,int lo,int hi){
        if(lo < hi){
            return;
        }
        int mid = lo +(hi-lo)/2;
       //分
        sort(list,lo,mid);
        sort(list,mid+1,hi);
        //治
        meger(list,lo,mid,hi);    //这个是归并的具体具体过程，咱们这篇介绍分治的重点，在此忽略了
    }

复制代码

快速排序

public static void sort(Comparable[] list){
        Collections.shuffle(list);  //消除输入的影响
        sort(list,0,list.length-1);
   }

    public static void sort(Comparable[] list,int lo,int hi){
        if(lo < hi){
            return;
        }
        int j = patition(list,lo,hi);    //快排中重要的切分，典型有三取样切分。找出大小为中间的点
                                                  在此忽略了具体实现，有兴趣看相关资料
        //分
        sort(list,lo,j-1);
        sort(list,j+1,hi);
    }

复制代码

快排和归并排序的能够概括的递推公式

T(n) = 2T(2/n) +O(n)
时间复杂度是 ）O(NlogN)
复制代码

参考资料

面对分治算法，看这两道题就够了