递归(回溯算法)

递归算法的常用解题思路：

1、写出递推公式
2、确定递归出口
3、根据递推公式写出代码

589. N 叉树的前序遍历

给定一个 N 叉树，返回其节点值的 前序遍历 。
N 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。
进阶：
递归法很简单，你可以使用迭代法完成此题吗?
示例 1：
输入：root = [1,null,3,2,4,null,5,6]
输出：[1,3,5,6,2,4]
示例 2：
输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,
null,13,null,null,14]
输出：[1,2,3,6,7,11,14,4,8,12,5,9,13,10]
提示：
N 叉树的高度小于或等于 1000
节点总数在范围 [0, 10^4] 内
Related Topics 栈 树 深度优先搜索

递推公式：
traversal(Node n) = 输出自己，然后for n in n.children {traversal(n)}
递归出口：
n.children==null

/*
class Node {
    public int val;
    public List<Node> children;

    public Node() {}
    public Node(int _val) {
        val = _val;
    }
    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};*/

import java.util.ArrayList;

class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> ans = new ArrayList<>();
        if(root==null) {
            return ans;
        }
        traversal(ans,root);
        return ans;
    }

    public void traversal(List<Integer> ans,Node root) {
    	// 输出自己
        ans.add(root.val);
        // 递归出口
        if (root.children == null) return;
        // 递推公式
        for(Node node : root.children) {
            traversal(ans,node);
        }
    }
}

剑指 Offer 55 - I. 二叉树的深度

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。
例如：
给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。
提示：
节点总数 <= 10000
注意：本题与主站 104 题相同：https:leetcode-cn.com/problems/maximum-depth-of-binary-tre
e/
Related Topics 树 深度优先搜索 广度优先搜索 二叉树

递推公式:
maxDepth(Node node) = max{maxDepth(node.left),maxDepth(node.right)}
递归出口：
node.left和node.right都为null

import java.util.ArrayList;
class Solution {
    /*    public class TreeNode {
            int val;
            TreeNode left;
            TreeNode right;

            TreeNode(int x) { val = x; }
        }*/
    int ans = 0;

    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        List<Integer> depthList = new ArrayList<>();
        doMaxDepth(root, depthList, 1);
        return ans;

    }

    public void doMaxDepth(TreeNode root, List<Integer> depthList, int depth) {
        if (root.left == null && root.right == null) {
            ans = Math.max(ans, depth);
        }
        if (root.left != null) {
            doMaxDepth(root.left, depthList, depth + 1);
        }
        if (root.right != null) {
            doMaxDepth(root.right, depthList, depth + 1);
        }
    }
}