Leedcode算法专题训练（分治法）

归并排序就是一个用分治法的经典例子，这里我用它来举例描述一下上面的步骤：

1、归并排序首先把原问题拆分成2个规模更小的子问题。
2、递归地求解子问题，当子问题规模足够小时，可以一下子解决它。在这个例子中就是，当数组中的元素只有1个时，自然就有序了。
3、最后，把子问题的解（已排好序的子数组）合并成原问题的解。

当待排序的序列长度为1时，递归“开始回升”，在这种情况下不要做任何工作，因为长度为1的每个序列都已排好序。归并排序算法的关键操作是“合并”步骤中两个已排序序列的合并。我们通过调用一个辅助过程Merge(A,p,q,r)来完成合并，其中A是一个数组，p、q和r是数组下标，满足p<=q<r。该过程假设子数组A[p,q]和A[q+1,r]都已排好序。它合并这两个子数组形成单一的已排好序的子数组并代替当前的子数组A[p,r]。

过程Merge按以下方式工作。回到我们玩扑克牌的例子，假设桌上有两堆牌面朝上的牌，每堆都已排序，最小的牌在顶上。我们希望把这两堆牌合并成单一的排好序的输出堆，牌面朝下地放在桌上。我们的基本步骤包括在牌面朝上的两堆牌的顶上两张牌中选取较小的一张，将该牌从其堆中移开（该堆的顶上将显露一张新牌）并牌面朝下地将该牌放置到输出堆。

下面是Merge的伪代码：

Merge(A,p,q,r)：

tmp[1,..,r-p+1]
i = p
j = q+1
while i <= q && j <= r
   if A[i] <= A[j]
	tmp[k++] = A[i++];
   else
	tmp[k++] = A[j++];
while i <= q
   tmp[k++] = A[i++];
while j <= r
   tmp[k++] = A[j++];
for k2 = 0 to tmp.length
   A[k2+p] = tmp[k2]; 

Java代码实现

public class Merge_sort_test {

	public static void Merge(int[] A,int p,int q,int r){

		int[] tmp = new int[r-p+1];//声明一个临时数组，长度为要归并数组的长度
		int i = p;   //记住左边数组第一个元素的下标
		int j = q+1; //记住右边数组第一个元素的下标
		int k = 0;
		while(i <= q && j <= r){
			//左边数组元素和右边数组元素比较，把小的元素赋给临时数组
			if(A[i] <= A[j]){
				tmp[k++] = A[i++];
			}
			else{
				tmp[k++] = A[j++];
			}
		}
		//把左边剩余的数组元素赋给临时数组
		while(i <= q){
			tmp[k++] = A[i++];
		}
		//把右边剩余的数组元素赋给临时数组
		while(j <= r){
			tmp[k++] = A[j++];
		}
		//用临时数组元素覆盖原数组元素
		for(int k2 = 0;k2 < tmp.length;k2++){
			A[k2+p] = tmp[k2];
		}
	}
	public static void/*int[]*/ Merge_sort(int[] A,int p,int r){

		int q = (p+r)/2;
		if(p < r){
			//递归调用
			Merge_sort(A,p,q);
			Merge_sort(A,q + 1,r);
			//归并排序数据元素
			Merge(A,p,q,r);
		}
		//return A;
	}
	public static void main(String[] args) {
		//
		int[] A = {5,2,4,7,1,3,2,6};
		System.out.println("原始数据： ");
		for(int i = 0;i < A.length;i++){

			System.out.print(A[i] + " ");
		}
		System.out.println();
		Merge_sort(A,0,A.length -1);
		System.out.println("输出结果： ");
		for(int i = 0;i < A.length;i++){

			System.out.print(A[i] + " ");
		}
	}

}

1. 给表达式加括号

241. Different Ways to Add Parentheses (Medium)

Leetcode / 力扣

Input: "2-1-1".

((2-1)-1) = 0
(2-(1-1)) = 2

Output : [0, 2]

这个解法真的很牛逼，注意分而治之的核心思想，先是把问题进行分解成一个小问题就是存储单个数字，然后再根据运算符进行计算

class Solution {
    public List<Integer> diffWaysToCompute(String input) {
        List<Integer> ways=new ArrayList<>();
        for(int i=0;i<input.length();i++){
            char c=input.charAt(i);
            if(c=='+' || c == '-'|| c=='*'){
                List<Integer> left = diffWaysToCompute(input.substring(0,i));
                List<Integer> right = diffWaysToCompute(input.substring(i+1));
                for(int l:left){
                    for(int r:right){
                        switch(c){
                            case '+':
                                ways.add(l+r);
                                break;
                            case '-':
                                ways.add(l-r);
                                break;
                            case '*':
                                ways.add(l*r);
                                break;
                        }
                    }
                }
            }
        }
        if(ways.size() == 0){
            ways.add(Integer.valueOf(input));
        }
        return ways;

    }
}

2. 不同的二叉搜索树

95. Unique Binary Search Trees II (Medium)

Leetcode / 力扣

给定一个数字 n，要求生成所有值为 1...n 的二叉搜索树。

Input: 3
Output:
[
  [1,null,3,2],
  [3,2,null,1],
  [3,1,null,null,2],
  [2,1,3],
  [1,null,2,null,3]
]
Explanation:
The above output corresponds to the 5 unique BST's shown below:

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

class Solution {
    public List<TreeNode> generateTrees(int n) {
        if(n==0)return new LinkedList<TreeNode>();
        return generateTrees(1,n);
    }
    public List<TreeNode> generateTrees(int start ,int end){
        List<TreeNode> allTrees = new LinkedList<TreeNode>();
        if(start > end){
            allTrees.add(null);
            return allTrees;
        }
        for(int i=start;i<=end;i++){
            List<TreeNode> leftTrees=generateTrees(start,i-1);
            List<TreeNode> rightTrees=generateTrees(i+1,end);
            for(TreeNode left:leftTrees){
                for(TreeNode right : rightTrees) {
                    TreeNode currTree = new TreeNode(i);
                    currTree.left=left;
                    currTree.right=right;
                    allTrees.add(currTree);
                }
            }
        }
        return allTrees;

    }
}