leetcode 104 22 46

【104】maximum-depth-of-binary-tree（二叉树的最大深度）

public class Solution {
	public int maxDepth(TreeNode root) {
		if(root == null) {
			return 0;
		}
		return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
	}
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

【22】generate-parentheses（生成括号）

import java.util.ArrayList;

public class Solution {
	
	public ArrayList<String> generateParenthesis(int n) {

		ArrayList<String> parenthesis = new ArrayList<String>();
		StringBuilder sb = new StringBuilder();
		generate(n,n,parenthesis,sb);

		return parenthesis;
	}
	
	void generate(int x,int y,ArrayList<String> parenthesis,StringBuilder sb) {
		
		if(x < 0 || y < 0 || x > y) return;
		
		if(x == 0 && y == 0) {
			parenthesis.add(sb.toString());
			return;
		}
		
		StringBuilder sb_temp = new StringBuilder();
		sb_temp.append(sb.toString());
		
		generate(x-1,y,parenthesis,sb.append("("));
		generate(x,y-1,parenthesis,sb_temp.append(")"));
		
	}
}

【46】permutations （全排列）

import java.util.ArrayList;

public class Solution {
	public ArrayList<ArrayList<Integer>> permute(int[] num) {

		ArrayList<ArrayList<Integer>> permuteList = new ArrayList<ArrayList<Integer>>();
		ArrayList<Integer> intList = new ArrayList<Integer>();
		generate(permuteList, intList, num, 0, num.length);
		return permuteList;
	}

	void generate(ArrayList<ArrayList<Integer>> permuteList, ArrayList<Integer> intList, int[] num, int current,
			int len) {

		if (current == len) {
			permuteList.add(intList);
			return;
		}
		int size = intList.size();
		for (int i = 0; i < size; i++) {
			ArrayList<Integer> intList_copy = (ArrayList<Integer>) intList.clone();
			intList_copy.add(i, num[current]);
			generate(permuteList, intList_copy, num, current + 1, len);
		}
		intList.add(num[current]);
		generate(permuteList, intList, num, current + 1, len);
	}
}