算法：递归（为主）

70.爬楼梯

class ClimbStairs {
    public static void main(String[] args) {
        ClimbStairs cs = new ClimbStairs();
        System.out.println(cs.climbStairs(5));
    }


	//dp[n] = dp[n-2] + dp[n-1]
    //初始化dp[0], dp[1]  dp[2] = dp[1] + dp[0] = 2； dp[1] = 1, dp[0] = 1
    public int climbStairs(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2;i<n+1;i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
}

22.括号生成

class generateParenthesis {
    //代码测试
    public static void main(String[] args) {
        generateParenthesis gp = new generateParenthesis();
        System.out.println(gp.generateParenthesis(3));
    }
    private List<String> result;
    public List<String> generateParenthesis(int n) {
        //返回数组
        result = new ArrayList<String>();
        generte(0, 0, n, "");

        return result;
    }
    //递归
    private void generte(int left, int right, int n, String s) {
        //terminator 终结条件
        if (left == n && right == n) {
            result.add(s);

            return;
        }

        //下探 if left<n "(" ++  if left > right ")" ++ until left == right == n
        if (left < n) {
            generte(left + 1, right, n, s + "(");
        }
        if (left > right) {
            generte(left, right + 1, n, s + ")");
        }
    }
}

226.翻转二叉树

//自顶向下递归
public TreeNode invertTree(TreeNode root) {
        //递归的终止条件：当节点为null才返回
        if (root==null){
            return null;
        }
    //将当前节点的左右子树进行交换
        TreeNode temp = root.right;
        root.right = root.left;
        root.left = temp;
    
    //递归交换当前节点的 左子树
        invertTree(root.left);
    //递归交换当前节点的 右子树
        invertTree(root.right);

        return root;
}

98.验证二叉搜索树

//中序遍历
class Solution {
    TreeNode pre = null;
    public boolean isValidBST(TreeNode root) {
        
        //递归终止条件
        if (root == null) {
            return true;
        }
        //访问左子树，如果左子树不存在 return false（中序 左-根-右）
        if (!isValidBST(root.left)){
            return false;
        }
        /**
        *访问当前节点：如果当前节点小于等于中序遍历的前一个节点，说明不满足BST，返回false，
        *else 继续遍历        
        */
        if (pre==null){
            pre = root;
        }else if (root.val<=pre.val){
            return false;
        }
        pre = root;

        return isValidBST(root.right);
    }
}

104.二叉树的最大深度

public int maxDepth(TreeNode root) {
        //递归终止条件
        if (root==null){
            return 0;
        }
        //递归下探
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        //返回最终结果
        return Math.max(left,right)+1;
}

111.二叉树的最小深度

public int minDepth(TreeNode root) {
        //递归终止条件
        if (root==null){
            return 0;
        }
        //处理并下探
        int left = minDepth(root.left);
        int right = minDepth(root.right);
        if (left==0){
            return right+1;
        }else if (right==0){
            return left+1;
        }
        return Math.min(left,right)+1;
    }

50.Pow(x,n)

class Pow {
    public static void main(String[] args) {
        Pow pow = new Pow();

        System.out.println(pow.myPow(2.00000 ,-2147483648));
    }

    //递归分治
    public double myPow(double x, int n) {
        if (x == 0.0) {
            return 0.0;
        }
        //处理n<0的情况
        long y = n;
        if (y < 0) {
            x = 1/x;
            y = -y;
        }
        //将问题化简成 最小问题 x^n -> x^(n/2)*x^(n/2) 或 x^(n/2)*x^(n/2)*x
        double result = 1.0;
        while (y > 0) {
            if (y % 2 == 1) {
                result *= x;
            }
            x *= x;
            y /= 2;
        }
        return result;
    }
}

78.子集

class Subsets {
    public static void main(String[] args) {
        Subsets subsets = new Subsets();
        int[] arr = {1,2,3};
        System.out.println(subsets.subsets(arr));
    }
    //递归
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        if (nums==null) {return ans;}
        dfs(ans,nums,new ArrayList<Integer>(),0);
        return ans;
    }

    private void dfs(List<List<Integer>> ans, int[] nums, List<Integer> list, int index) {
        //递归结束条件
        if (index==nums.length){
            ans.add(new ArrayList<Integer>(list));
            return;
        }
        //处理递归
        dfs(ans,nums,list,index+1);

        list.add(nums[index]);
        dfs(ans,nums,list,index+1);
        //复原list
        list.remove(list.size()-1);
    }
}

242.有效的字母异位词

class Solution{
public static boolean isAnagram(String str1, String str2) {
        if (str1.length() != str2.length()) {
            return false;
        }
    //数组转换
        char[] strs = str1.toCharArray();
        char[] strt = str2.toCharArray();
 	//排序并返回给当前数组
    	Arrays.sort(strs);
        Arrays.sort(strt);
        return Arrays.equals(strs, strt);
    }
}

62.不同路径

public class UniquePaths {
    public static void main(String[] args) {
        UniquePaths unique = new UniquePaths();
        System.out.println(unique.uniquePaths(3, 7));
    }

	//动态规划
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }
        for (int i = 1;i<m;i++){
            for (int j = 1;j<n;j++){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }

        return dp[m - 1][n - 1];
    }
}