这是我参与8月更文挑战的第7天，活动详情查看：8月更文挑战

一、 二叉树的前序遍历

144. 二叉树的前序遍历（力扣）

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

• 输入：root = [1,null,2,3]
• 输出：[1,2,3]

示例 2：

• 输入：root = []
• 输出：[]

示例 3：

• 输入：root = [1]
• 输出：[1]

示例 4：

• 输入：root = [1,2]
• 输出：[1,2]

示例 5：

• 输入：root = [1,null,2]
• 输出：[1,2]

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100   来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/bi… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

设置一个ans作为最后的返回数组。 设置一个递归方法dfs来实现整个二叉树的前序遍历，具体操作如下：

• 判断传入的节点是否为null,如果为null时结束执行。
• 由于是前序遍历，所以先执行根节点，再执行左右节点。根节点的操作是将根节点放入ans数组中。左右节点分别当成根节点，进行递归操作。
• 最后返回ans。

代码实现

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * 递归算法实现前序遍历
 * @param {TreeNode} root
 * @param {number[]} ans
 */
var dfs = function(root, ans) {
    if(root == null) return root;
    ans.push(root.val);
    dfs(root.left, ans);
    dfs(root.right, ans);
}
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var preorderTraversal = function(root) {
    let ans = [];
    dfs(root, ans);
    return ans;
};

二、N 叉树的前序遍历

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] 内

来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/n-… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

N叉树与二叉树的前序遍历相似，只不过二叉树是设置了左右节点，而N叉树是将所有子节点放到children数组中，只要遍历children数组中的节点即可对子节点进行递归操作。

设置一个ans作为最后的返回数组。 设置一个递归方法dfs来实现整个N叉树的前序遍历，具体操作如下：

• 判断传入的节点是否为null,如果为null时结束执行。
• 由于是前序遍历，所以先执行根节点，再执行子节点。根节点的操作是将根节点放入ans数组中。遍历根节点下的所有子节点，对他们进行递归操作。
• 最后返回ans。

代码实现：

/**
 * // Definition for a Node.
 * function Node(val, children) {
 *    this.val = val;
 *    this.children = children;
 * };
 */
/**
 * 递归算法实现前序遍历
 * @param {TreeNode} root
 * @param {number[]} ans
 */
var dfs = function(root, ans){
    if(root == null) return root;
    ans.push(root.val);
    // 遍历所有子节点,进行递归
    for(let i = 0; i < root.children.length; i++) {
        dfs(root.children[i],ans);
    }
}
/**
 * @param {Node|null} root
 * @return {number[]}
 */
var preorder = function(root) {
    let ans = [];
    dfs(root, ans);
    return ans;
};

三、翻转二叉树

226. 翻转二叉树

翻转一棵二叉树。

示例：

输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/in… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路 翻转二叉树可以采用递归的方式，将所有左右节点互换位置即可。

代码实现

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */

/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var invertTree = function(root) {
    if(root == null) return root;
    // 左右节点互换位置
    const temp = root.left;
    root.left = root.right;
    root.right = temp;

    invertTree(root.left);
    invertTree(root.right);
    return root;
};

四、从上到下打印二叉树 II

剑指 Offer 32 - II. 从上到下打印二叉树 II

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例如: 给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

提示：节点总数 <= 1000

来源：力扣（LeetCode） 链接：leetcode-cn.com/problems/co… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

想要一层一层的输出每一层的节点值，可以选择任意一种方式（前中后序）去遍历整个二叉树，遍历时记录一下当前在第几层，就将当前节点值放到第几层的数组中。

代码实现

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number[][]} ans
 * @param {number} deep
 */
var dfs = function(root, ans, deep) {
    if(root == null) return;
    // 当第deep层没有数据时，ans加入一个空数组，防止后面使用ans[deep]时报错
    if(deep == ans.length) {
        ans.push([]);
    }
    ans[deep].push(root.val);
    dfs(root.left, ans, deep + 1);
    dfs(root.right, ans, deep + 1);
} 
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
    let ans = new Array();
    dfs(root, ans, 0)
    return ans;
};