代码随想录 二叉树 Java （一）

已于 2023-06-14 09:05:47 修改
阅读量688 收藏
点赞数
分类专栏： 代码随想录 文章标签： java 算法 数据结构
于 2023-06-04 09:38:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guliguliguliguli/article/details/130941141
版权

文章目录

（简单）144. 二叉树的前序遍历

在这里插入图片描述
在这里插入图片描述

递归方式

class Solution {

    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        preOrder(root, list);
        return list;
    }

    public void preOrder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        list.add(root.val);
        preOrder(root.left, list);
        preOrder(root.right, list);
    }
}

复杂度分析：

  • 时间复杂度：O(n)，其中n是二叉树的节点数。每一个节点恰好被遍历一次。
  • 空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为O(logn)，最坏情况下树呈现链状，为O(n)。

在这里插入图片描述

非递归方式，使用Stack

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        list.add(root.val);
        TreeNode node = root.left;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                list.add(node.val);
                stack.push(node);
                node = node.left;
            }
            node = stack.pop().right;
        }
        return list;
    }
}

复杂度分析：

  • 时间复杂度：O(n)，其中n是二叉树的节点数。每一个节点恰好被遍历一次。
  • 空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为O(logn)，最坏情况下树呈现链状，为O(n)。
    在这里插入图片描述

使用BFS的思想，利用栈，实现二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            list.add(node.val);
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
        return list;
    }
}

在这里插入图片描述

（简单）94. 二叉树的中序遍历

在这里插入图片描述
在这里插入图片描述
递归方式

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        inOrder(root, list);
        return list;
    }

    public void inOrder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inOrder(root.left, list);
        list.add(root.val);
        inOrder(root.right, list);
    }
}

复杂度分析：

  • 时间复杂度：O(n)，其中n为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
  • 空间复杂度：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到O(n)的级别。

非递归方式

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        TreeNode node = root.left;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            list.add(node.val);
            node = node.right;
        }
        return list;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，其中n为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
  • 空间复杂度：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到O(n)的级别。

（简单）145. 二叉树的后序遍历

在这里插入图片描述
在这里插入图片描述
递归方式

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
import java.util.ArrayList;
import java.util.List;

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        postOrder(root, list);
        return list;
    }

    public void postOrder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        postOrder(root.left, list);
        postOrder(root.right, list);
        list.add(root.val);
    }
}

复杂度分析：

  • 时间复杂度：O(n)，其中n是二叉搜索树的节点数。每一个节点恰好被遍历一遍
  • 空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为O(logn)，最坏情况下呈现链状，为O(n)
    在这里插入图片描述
    非递归形式

后序遍历的顺序是，左，右，根

后序遍历和前序、中序遍历略微有点不同，因为每一棵子树的根节点可能需要二次入栈。从栈中弹出某一根节点时，需要判断该节点的右子树是否为空，如果为空，或者该节点的右子树已经遍历过，则将该根节点的值加入list中。如果没有遍历过该节点的右子树，则重新将根节点入栈，并开始遍历右子树。

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        TreeNode node = root.left;
        TreeNode prev = null;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            //root.right==prev，表示该节点的右子树一定遍历完成
            if (node.right == null || node.right == prev) {
                list.add(node.val);
                prev = node;
                node = null;
            } else {
                //还没有遍历右子树
                stack.push(node);
                node = node.right;
            }

        }
        return list;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，其中n是二叉搜索树的节点数。每一个节点恰好被遍历一遍
  • 空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为O(logn)，最坏情况下呈现链状，为O(n)

前一个非递归实现的后续遍历是深度有限搜索DFS的思想

在代码随想录中还提到一种后序遍历的方式，先序遍历时根左右、后序遍历的左右根，只需要调整一下先序遍历的代码顺序，就变成了根右左的顺序，然后反转result数组，输出的结果顺序就是左右中了

这种方法是广度优先遍历BFS的思想，依照该思想，也可以实现前序遍历，已在上面的前序遍历题目中进行补充

下面代码从栈中弹出来的顺序是：根、右、左，然后将结果list反转一下即可

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

二叉树的统一遍历方法（参考代码随想录）

非递归方式，也称作迭代法

在DFS的思想下，前序遍历和中序遍历的代码类似，只需要调整代码中节点值加入结果list的位置即可，和后序遍历的代码差别较大

使用BFS的思想，前序遍历和后序遍历的代码类似，只需要修改左子节点和右子节点入栈的先后顺序即可，和中序遍历的代码差别较大

但是，使用递归的方式，前序遍历、中序遍历、后序遍历都只需要微微调整一下代码就可以，代码随想录中给出了一种统一风格的代码

以中序遍历为例，使用栈，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。

对上面这段话的简单解释：
中序遍历是左根右，先访问二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是把节点的数值放进result数组中），这就造成了处理顺序与访问顺序不一致的情况

为了解决这个不一致，将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。标记的方法是把要处理的节点放入栈中之后，紧接着放入一个空指针作为标记。

使用“统一”的方式写中序遍历

再进行了一两次单步调试后，有点理解这种方式，首先，依赖栈后进先出的特性，按照右、中、左的顺序将节点压入栈中，其次是，对于已经访问过，但是还没有处理的根节点，使用null进行标记。

import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root != null) {
            stack.push(root);
        }
        while (!stack.isEmpty()) {
            TreeNode node = stack.peek();
            stack.pop();
            if (node != null) {
                if (node.right != null) {
                    stack.push(node.right);//右
                }
                stack.push(node);//中
                stack.push(null);
                if (node.left != null) {
                    stack.push(node.left);//左
                }
            } else {
                node = stack.peek();
                result.add(node.val);
                stack.pop();
            }
        }
        return result;
    }
}

在这里插入图片描述
使用同样的方法，前序遍历代码

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root != null) {
            stack.push(root);
        }
        while (!stack.isEmpty()) {
            TreeNode node = stack.peek();
            stack.pop();
            if (node != null) {
                if (node.right != null) {
                    stack.push(node.right);
                }
                if (node.left != null) {
                    stack.push(node.left);
                }
                stack.push(node);
                stack.push(null);
            } else {
                node = stack.peek();
                result.add(node.val);
                stack.pop();
            }
        }
        return result;
    }
}

在这里插入图片描述

使用类似的方法，实现后序遍历

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        if (root != null) {
            stack.push(root);
        }
        while (!stack.isEmpty()) {
            TreeNode node = stack.peek();
            stack.pop();
            if (node != null) {
                stack.push(node);
                stack.push(null);
                if (node.right != null) {
                    stack.push(node.right);
                }
                if (node.left != null) {
                    stack.push(node.left);
                }
            } else {
                node = stack.peek();
                result.add(node.val);
                stack.pop();
            }
        }
        return result;
    }
}

在这里插入图片描述

（中等）102. 二叉树的层序遍历

在这里插入图片描述

在处理某一层的节点之前，先记录一下队列中元素的个数，也就是这一层的节点个数，然后依次弹出这一层的节点，然后再向队列中添加该节点的左子节点和右子节点（如果有的话）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode node;
        while (!queue.isEmpty()) {
            ArrayList<Integer> list = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                node = queue.poll();
                list.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            result.add(list);
        }
        return result;
    }
}

（中等）107. 二叉树的层序遍历II

在这里插入图片描述

因为返回的结果只要是实现了List接口就可以，所以，ArrayList、LinkedList都可以，本题中要求层序遍历是自底向上的层序遍历，依然可以按照102题中的方法去写，只不过每一次往结果List中添加结果时，需要添加在头部的位置，ArrayList底层是数组实现，所以总是从头部插入元素效率较低，所以使用LinkedList，底层使用双向链表，在头部插入元素在O(1)的时间内即可完成

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> result = new LinkedList<>();
        if (root == null) {
            return result;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        int size = 0;
        TreeNode tmp;
        queue.offer(root);
        while (!queue.isEmpty()) {
            size = queue.size();
            LinkedList<Integer> list = new LinkedList<>();
            for (int i = 0; i < size; i++) {
                tmp = queue.poll();
                list.addLast(tmp.val);
                if (tmp.left != null) {
                    queue.add(tmp.left);
                }
                if (tmp.right != null) {
                    queue.add(tmp.right);
                }
            }
            result.addFirst(list);
        }
        return result;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，其中n是二叉树节点的个数。每个节点访问一次，结果列表使用链表的结构时，在结果列表头部添加一层节点值的列表的时间复杂度是O(1)，因此总时间复杂度是O(n)。
  • 空间复杂度：O(n)，其中n是二叉树中的节点个数。空间复杂度取决于队列开销，队列中的节点个数不会超过n。

（中等）199. 二叉树的右视图

在这里插入图片描述

在这里插入图片描述
还是使用层次遍历的思想（BFS），只不过结果列表中添加的是每一层的最右边的节点

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        int size = 0;
        TreeNode node;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            size = queue.size();
            for (int i = 1; i <= size; i++) {
                node = queue.poll();
                if (i == size) {
                    result.add(node.val);
                }

                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }
        return result;
    }
}

在这里插入图片描述
看题解，也可以使用DFS的思路

按照 根节点、右子树、左子树的顺序访问，就可以保证每层都是最先访问最右边的节点的。

（与先序遍历 根节点、左子树、右子树 正好相反，先序遍历每层最先访问的是最左边节点）

时间复杂度：O(N)，每个节点都被访问过1次
空间复杂度：O(N)，因为这不是一棵平衡二叉树，二叉树的深度至少是logN，最坏的情况下会退化成一条链表，深度为N，因此递归使用的栈空间O(N)的。

class Solution {

    List<Integer> result = new ArrayList<>();

    public List<Integer> rightSideView(TreeNode root) {
        dfs(root, 0);
        return result;
    }

    public void dfs(TreeNode root, int depth) {
        if (root == null) {
            return;
        }
        if (depth == result.size()) {
            result.add(root.val);
        }
        depth++;
        dfs(root.right, depth);
        dfs(root.left, depth);
    }
}

在这里插入图片描述

（简单）637. 二叉树的层平均值

在这里插入图片描述
在这里插入图片描述

广度优先搜索BFS

还是层次遍历的思路，在弹出每一层节点之前，记录队列当前的size，在弹出这一层每一个节点时，对它们的值进行累加求和，当这一层的节点全部弹出时，将求和的结果除以size，就是这一层的平均值，添加到结果列表中

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            double sum = 0.0;
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                sum += node.val;
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            sum /= size;
            res.add(sum);
        }
        return res;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，其中n是二叉树中的节点个数

    • 广度优先搜索需要对每个节点访问一次，时间复杂度是O(n)。
    • 需要对二叉树的每一层计算平均值，时间复杂度是O(h)，其中h是二叉树的高度，在任何情况下都满足h<=n。
    • 因此总时间复杂度是O(n)

  • 空间复杂度：O(n)，其中n是二叉树中的节点个数。空间复杂度取决于队列开销，队列中的节点个数不会超过n。

深度优先搜索DFS

使用深度优先搜索计算二叉树的层平均值，需要维护两个数组，counts用于存储二叉树的每一层的节点数，sums用于存储二叉树的每一层的节点值之和。搜索过程中需要记录当前节点所在层，如果访问到的节点在第i层，则将counts[i]的值加1，并将该节点的值加到sums[i]。

遍历结束之后，第i层的平均值即为sums[i]/counts[i]。

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        ArrayList<Integer> counts = new ArrayList<>();
        ArrayList<Double> sums = new ArrayList<>();
        dfs(root, 0, counts, sums);
        ArrayList<Double> res = new ArrayList<>();
        //size表示该二叉树有多少层
        dfs(root, 0, counts, sums);
        int size = sums.size();
        for (int i = 0; i < size; i++) {
            res.add(sums.get(i) / counts.get(i));
        }
        return res;
    }

    private void dfs(TreeNode root, int depth, ArrayList<Integer> counts, ArrayList<Double> sums) {
        if (root == null) {
            return;
        }
        if (depth < sums.size()) {
            sums.set(depth, sums.get(depth) + root.val);
            counts.set(depth, counts.get(depth) + 1);
        } else {
            sums.add(1.0 * root.val);
            counts.add(1);
        }
        dfs(root.left, depth + 1, counts, sums);
        dfs(root.right, depth + 1, counts, sums);
    }
}

在这里插入图片描述

（中等）429. N叉树的层序遍历

在这里插入图片描述
在这里插入图片描述
这一题和二叉树的层序遍历思想一样，区别在于，二叉树的层序遍历，向结果列表中添加当前节点的值以后，需要判断该节点的左子节点和右子节点是否为空，不为空的话加入队列。对于N叉树，则需要判断当前Node对象的children属性，如果里面有不为空的子节点，需要将它们加入队列

/*
// Definition for a Node.
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;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        ArrayList<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        
        Queue<Node> queue = new LinkedList<>();
        
        int size;
        Node node;
        List<Integer> list;

        queue.add(root);
        while (!queue.isEmpty()) {

            size = queue.size();
            list = new ArrayList<>();

            for (int i = 0; i < size; i++) {
                node = queue.poll();
                list.add(node.val);
                for (Node child : node.children) {
                    if (child != null) {
                        queue.add(child);
                    }
                }
            }

            res.add(list);
        }
        return res;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，其中n是树中包含的节点个数。在广度优先搜索的过程中，我们需要遍历每个节点恰好一次。
  • 空间复杂度：O(n)，即为队列需要使用的空间。在最坏的情况下，树只有两层，且最后一层有n-1个节点，此时就需要O(n)的空间。

（中等）在每个树行中找最大值

在这里插入图片描述
在这里插入图片描述
采用层序遍历的思想，使用一个变量tmp来记录当前层的最大值，在比较完当前层的所有值以后，将其添加到结果列表中

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        int tmp;
        int size;
        TreeNode node;
        Queue<TreeNode> queue = new LinkedList<>();

        queue.add(root);
        while (!queue.isEmpty()) {
            size = queue.size();
            tmp = Integer.MIN_VALUE;
            for (int i = 0; i < size; i++) {
                node = queue.poll();
                tmp = Math.max(tmp, node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            res.add(tmp);
        }
        return res;
    }
}

在这里插入图片描述

复杂度分析：

  • 时间复杂度：O(n)，其中n为二叉树节点个数，每一个节点仅会进出队列一次。
  • 空间复杂度：O(n)，存储二叉树节点的空间开销。

深度优先搜索DFS

用树的【先序遍历】来进行【深度优先搜索】处理，并用curHeight来标记遍历到的当前节点的高度。当遍历到curHeight高度的节点就判断是否更新该节点的最大值。

import java.util.ArrayList;
import java.util.List;

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        dfs(root, 0, res);
        return res;
    }

    private void dfs(TreeNode root, int curHeight, List<Integer> res) {
        if (root == null) {
            return;
        }
        if (curHeight == res.size()) {
            res.add(root.val);
        } else {
            res.set(curHeight, Math.max(root.val, res.get(curHeight)));
        }
        dfs(root.left, curHeight + 1, res);
        dfs(root.right, curHeight + 1, res);
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，其中n为二叉树节点个数。二叉树的遍历中每个节点都会被访问一次且只会被访问一次。
  • 空间复杂度：O(height)，其中height表示二叉树的高度。递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。

（中等）116. 填充每个节点的下一个右侧节点指针

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
层序遍历的思路。

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }

        Queue<Node> queue = new LinkedList<>();
        int size;
        Node node;

        queue.add(root);
        while (!queue.isEmpty()) {
            size = queue.size();
            for (int i = 1; i <= size; i++) {
                node = queue.poll();
                if (i == size) {
                    node.next = null;
                } else {
                    node.next = queue.peek();
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }
        return root;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)。每个节点会被访问一次，即从队列中弹出，并建立next指针。
  • 空间复杂度：O(N)。这是一棵完美二叉树，它的最后一个层级包含N/2个节点。广度优先遍历的复杂度取决于一个层级上的最大元素数量。

官方提供的另一种方法，使用已建立的next指针

思路：

一棵树中存在两种类型的next指针

  1. 第一种情况是连接同一个父节点的两个子节点。它们可以通过同一个节点直接访问到，因此直接可以执行下面的操作即可完成连接。
node.left.next = node.right;

在这里插入图片描述

  1. 第二种情况在不同父亲的子节点之间建立连接，这种情况不能直接连接。
    • 如果每个节点有指向父节点的指针，可以通过该指针找到next节点。第N层节点之间建立next指针后，再建立第N+1层节点的next指针。可以通过next指针访问同一层的所有节点，因此可以使用第N层的next指针，为第N+1层节点建立next指针。
node.right.next = node.next.left;

在这里插入图片描述
从根节点开始，由于第0层只有一个节点，所以不需要连接，直接为第一层节点建立next指针即可。该算法中需要注意一点是，当我们为第N层节点建立next指针时，处于第N-1层。当第N层节点的next指针全部建立完成后，移至第N+1层节点的next指针。

遍历某一层的节点时，这层节点的next指针已经建立。因此我们只需要知道这一层的最左节点，就可以按照链表方式遍历，不需要使用队列。

完成当前层的连接后，进入下一层重复操作，直到所有的节点全部连接。进入下一层后需要更新最左节点，然后从新的最左结点开始遍历该层所有节点。因为是完美二叉树，因此最左节点一定是当前最左节点的左孩子。如果当前最左节点的左孩子不存在，说明已经到达该树的最后一层，完成了所有节点的连接。

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }
        //从根节点开始
        Node leftmost = root;
        while (leftmost.left != null) {
            Node head = leftmost;
            while (head != null) {
                //连接1
                head.left.next = head.right;

                //连接2
                if (head.next != null) {
                    head.right.next = head.next.left;
                }

                //指针向后移动
                head = head.next;
            }
            //去往下一层
            leftmost = leftmost.left;
        }
        return root;
    }
}

指针永远指向的是被操作行的上一层，因为上一层的next指针已经建立完毕

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，每个节点只访问一次。
  • 空间复杂度：O(1)，不需要存储额外的节点。

（中等）117. 填充每个节点的下一个右侧节点指针II

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
这一题和上一题116的区别是，上一题是完美二叉树，这一题是普通二叉树，其实思路是一样的。

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 1; i <= size; i++) {
                Node node = queue.poll();
                if (i == size) {
                    node.next = null;
                } else {
                    node.next = queue.peek();
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }
        return root;
    }
}

在这里插入图片描述
上面代码的运行效率并不是很高，这是因为我们把节点不停地入队，然后不停地出队，其实可以不需要队列，每一行都可以看成一个链表比如第一行就只有一个节点的链表，第二行是只有两个节点的链表（假如根节点的左右两个子节点都不为空）…

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if (root == null) {
            return null;
        }
        //cur可以把它看作是每一层的链表
        Node cur = root;
        while (cur != null) {
            //遍历当前层的时候
            //为了方便操作在下一层前面添加一个哑节点
            //（注意，这里是访问当前层的节点，然后把下一层的节点串起来）
            Node dummy = new Node(0);
            Node pre = dummy;

            //开始遍历当前层的链表
            while (cur != null) {
                if (cur.left != null) {
                    //如果当前节点的左子节点不为空
                    //就让pre节点的next指向它，把它串起来
                    pre.next = cur.left;
                    pre = pre.next;
                }
                //同理
                if (cur.right != null) {
                    pre.next = cur.right;
                    pre = pre.next;
                }
                //继续访问这一行的下一个节点
                cur = cur.next;
            }
            //把下一层串联成一个链表之后，让他赋值给cur
            //后续继续循环，直到cur为空为止
            cur = dummy.next;
        }
        return root;
    }
}

因为上一题的二叉树是完美二叉树，也就是二叉树每一层都是满的状态。不过这一题就不是了，所以需要引入一个哑节点来，该节点的next指针指向的就是当前层的第一个二叉树节点。

在这里插入图片描述

（简单）104. 二叉树的最大深度

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

如果知道了左子树和右子树的最大深度l和r，那么该二叉树的最大深度即为max(l,r)+1

而左子树和右子树的最大深度又可以以同样的方式进行计算。因此可以用【深度优先搜索】的方法来计算二叉树的最大深度。具体而言，再计算当前二叉树的最大深度时，可以先递归计算出其左子树和右子树的最大深度，然后再O(1)时间内算出当前二叉树的最大深度。递归再访问到空节点时退出。
在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，其中n为二叉树节点的个数。每个节点在递归中只被遍历一次。
  • 空间复杂度：O(height)，其中height表示二叉树的高度。递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。

另一种思路：广度优先搜索

层序遍历的思路，队列中存放的是当前层的所有节点。每次扩展下一层的时候，不同于广度优先搜索的每次只从队列中拿出一个节点，而是需要将队列里所有节点都拿出来进行扩展，这样能保证每次拓展完的时候队列里存放的是当前层的所有节点，即是一层一层地进行拓展，最后用一个变量ans来维护拓展地次数，该二叉树地最大深度即为ans。

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        //res记录要返回的结果
        int res = 0;

        //size表示当前层的节点个数
        int size = 0;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            //该层的所有节点都已经扩展完毕，深度+1
            res++;
        }
        return res;
        
    }
}

（简单）111. 二叉树的最小深度

在这里插入图片描述

深度优先搜索

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        //该节点的左右子树都不为空
        if (root.left != null && root.right != null) {
            return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
        } else if (root.left == null && root.right != null) {
            //该节点的左子树为空，右子树不为空
            return minDepth(root.right) + 1;
        } else if (root.left != null) {
            //该节点的左子树不为空，右子树为空
            return minDepth(root.left) + 1;
        } else {
            //该节点为叶子节点，左子树右子树均为空
            return 1;
        }
    }
}

在这里插入图片描述

对于每一个非叶子节点，只需要分别计算其左右子树的最小叶子节点深度。

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
        int min_depth = Integer.MAX_VALUE;
        if (root.left != null) {
            min_depth = Math.min(minDepth(root.left), min_depth);
        }
        if (root.right != null) {
            min_depth = Math.min(minDepth(root.right), min_depth);
        }
        return min_depth + 1;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(N)，其中N是树的节点数。对每个节点访问一次。
  • 空间复杂度：O(H)，其中H是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度为O(logN)

广度优先搜索

遍历整棵二叉树，除了可以用深度优先搜索的方法，还可以使用广度优先遍历。

当找到一个叶子节点时，直接返回这个叶子节点的深度。广度优先搜索的性质保证了最先搜索到的叶子节点的深度一定最小。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int depth = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left == null && node.right == null) {
                    return depth;
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }
        return depth;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(N)，其中N是树的节点数。对每个节点访问一次。
  • 空间复杂度：O(N)，其中N是树的节点数。空间复杂度主要取决于队列的开销，队列中的元素个数不会超过树的节点数。

（简单 经典）226. 翻转二叉树

在这里插入图片描述
一看到这个题，我就觉得要用递归，逐层分解

从根节点开始，递归地对树进行遍历，并从叶子节点先开始翻转，如果当前遍历到的节点root的左右两棵子树都已经翻转，那么只需要交换两棵子树的位置，即可完成以root为根节点的整棵子树的翻转。

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        if (root.left == null && root.right == null) {
            return root;
        }
        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);
        root.left = right;
        root.right = left;
        return root;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(N)，其中N为二叉树节点的数目。需要遍历二叉树种的每一个节点，对每个节点而言，再常数时间内就可以完成交换两棵子树的操作。
  • 空间复杂度：O(N)，使用的空间由递归栈的深度决定，它等于当前节点在二叉树中的高度。在平均情况下，二叉树的高度与节点个数为对数关系，即O(logN)。而在最情况下，树形成链状，空间复杂度为O(N)

广度优先遍历

动画演示，参考链接

广度优先遍历需要额外的数据结构——队列，来存放临时遍历到的元素

首先需要将根节点放入到队列中，然后不断地迭代队列中的元素。
对当前元素调换其左右子树的位置，然后：

  • 判断其左子树是否为空，不为空就放入队列中
  • 判断其右子树是否为空，不为空就放入队列中

在这里插入图片描述

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
                if (node.right != null || node.left != null) {
                    TreeNode tmp = node.left;
                    node.left = node.right;
                    node.right = tmp;
                }
            }
        }
        return root;
    }
}

在这里插入图片描述

（简单）101. 对称二叉树

在这里插入图片描述

写这一题的时候，我想的是，要判断一个二叉树是否对称，则需要判断它的左子树和右子树是否对称，如果只有左子树或者只有右子树，那么就肯定不是对称的，如果左右子树都存在，那么如果左子树的根节点的值与右子树根节点的值不一样，也不是对称的，如果值一样，则需要比较该左子树的左孩子和右子树的右孩子，以及左子树的右孩子和右子树的左孩子是否是对称的。

所以和求最大深度不同，不能只靠原有的那个方法进行递归，而是需要另外写一个方法。

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return checkLeftAndRight(root.left, root.right);
    }

    public boolean checkLeftAndRight(TreeNode leftNode, TreeNode rightNode) {
        //左子树为空，右子树不为空
        if (leftNode == null && rightNode != null) {
            return false;
        }

        //左子树不为空，右子树为空
        if (leftNode != null && rightNode == null) {
            return false;
        }

        //左子树为空，右子树为空
        if (leftNode == null) {
            return true;
        }

        //左右子树都不为空
        //如果他们的值不相等
        if (leftNode.val != rightNode.val) {
            return false;
        }

        return checkLeftAndRight(leftNode.left, rightNode.right)
                && checkLeftAndRight(leftNode.right, rightNode.left);
    }
}

复杂度分析：

假设树上一共有n个节点。

  • 时间复杂度：O(n)，因为遍历了整棵树
  • 空间复杂度：O(n)，空间复杂度和递归使用的栈空间有关，这里递归层数不超过n。

官方对递归方法的总结：
如果一个左子树与右子树镜像对称，那么这个树是对称的。那么问题就转化为，两棵树在什么情况下互为镜像？

同时满足下面两个条件，两棵树互为镜像：

  • 它们的两个根节点具有相同的值
  • 每个树的右子树与另一个树的左子树镜像对称

另一种解题思路：迭代

引入一个队列，这是把递归程序改写成迭代程序的常用方法。初始化时我们把根节点入队两次。每次提取两个节点比较它们的值（队列中每两个连续的节点应该是相等的，而且它们的子树互为镜像），然后将两个节点的左右子节点按相反的顺序插入队列中。当队列为空时，或者检测到树不对称（即从队列中取出两个不相等的连续节点）时，该算法结束。

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode node1 = queue.poll();
            TreeNode node2 = queue.poll();

            if (node1 == null && node2 == null) {
                continue;
            }

            if (node1==null || node2==null) {
                return false;
            }

            if (node1.val != node2.val) {
                return false;
            }            

            queue.add(node1.left);
            queue.add(node2.right);


            queue.add(node1.right);
            queue.add(node2.left);
        }
        return true;
    }
}

在这里插入图片描述

复杂度分析：

  • 时间复杂度：O(n)，n为二叉树中的节点，需要遍历整个二叉树
  • 空间复杂度：O(n)，这里需要用一个队列来维护节点，每个节点最多进队一次，出队一次，队列中最多不会超过n个点。

（简单）100. 相同的树

在这里插入图片描述

DFS思路

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) {
            return true;
        }
        if (p == null || q == null) {
            return false;
        }
        if (p.val != q.val) {
            return false;
        }
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(min(m,n))，其中m和n分别是两个二叉树的节点数。对两个二叉树同时进行深度优先搜索，只有当两个二叉树中的对应节点都不为空时才会访问到该节点，因此被访问到的节点数不会超过较小的二叉树的节点数。
  • 空间复杂度：O(min(m,n))，其中m和n是两个二叉树的节点数。空间复杂度取决于递归调用的层数，递归调用的层数不会超过较小的二叉树的最大高度，最坏情况下，二叉树的高度等于节点数。

BFS思路

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {

        if (p == null && q == null) {
            return true;
        }
        if (p == null || q == null) {
            return false;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(p);
        queue.add(q);
        while (!queue.isEmpty()) {
            TreeNode n1 = queue.poll();
            TreeNode n2 = queue.poll();
            if (n1 == null && n2 == null) {
                continue;
            }
            if (n1 == null || n2 == null) {
                return false;
            }
            if (n1.val != n2.val) {
                return false;
            }
            queue.add(n1.left);
            queue.add(n2.left);

            queue.add(n1.right);
            queue.add(n2.right);
        }
        return true;
    }
}

在这里插入图片描述
复杂度分析：和上面的DFS思路一样。

（简单）572. 另一棵树的子树

在这里插入图片描述
在这里插入图片描述

我的思路是：使用层次遍历的方式，遍历二叉树，当遇到某一根节点的val与subRoot根节点的val相同的时候，就判断这两棵二叉树是否长得一样，这块的代码和LeetCode 第100题 相同的树的代码是一样的。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.val == subRoot.val && isSame(node, subRoot)) {
                    return true;
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }
        return false;
    }

    public boolean isSame(TreeNode root, TreeNode subRoot) {
        if (root == null && subRoot == null) {
            return true;
        }
        if (root == null || subRoot == null) {
            return false;
        }
        if (root.val != subRoot.val) {
            return false;
        }
        return isSame(root.left, subRoot.left) && isSame(root.right, subRoot.right);
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(s x t)，s是二叉树中的节点的个数，t是子树中的节点的个数。对于每一个s上的点，都需要做一次深度优先搜索来和t匹配，匹配一次的时间代价是O(t)，那么总时间就是O(s x t)
  • 空间复杂度：假设s深度为ds，t的深度为dt，任意时刻栈空间的最大使用代价是O(max(ds,dt))。

官方提供的另一种思路，KMP

（简单）559. N叉树的最大深度

在这里插入图片描述
在这里插入图片描述

采用层序遍历的方式计算N叉树的最大深度，广度优先搜索

/*
// Definition for a Node.
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.LinkedList;
import java.util.Queue;

class Solution {
    public int maxDepth(Node root) {
        if (root == null) {
            return 0;
        }
        int depth = 0;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            depth++;
            for (int i = 0; i < size; i++) {
                Node node = queue.poll();
                for (Node n : node.children) {
                    if (n != null) {
                        queue.add(n);
                    }
                }
            }
        }
        return depth;
    }
}

在这里插入图片描述

复杂度分析：

  • 时间复杂度：O(n)，其中n是N叉树的节点个数。每个节点只会被访问一次。
  • 空间复杂度：此方法空间的消耗取决于队列存储的元素数量，其在最坏情况下会达到O(n)

另一种方法，深度优先搜索DFS

如果根节点有N个子节点，则这N个子节点对应N个子树。记N个子树的最大深度中的最大值为maxChildDepth，则该N叉树的最大深度为maxChildDepth+1。

每个子树的最大深度又可以以同样的方式进行计算。因此，可以使用【深度优先搜索】的方法计算N叉树的最大深度。具体而言，在计算当前N叉树的最大深度时，可以先递归计算出其每个子树的最大深度，然后在O(1)的时间内计算出当前N叉树的最大深度。递归在访问到空节点时退出。

class Solution {
    public int maxDepth(Node root) {
        if (root == null) {
            return 0;
        }
        int maxChildDepth = 0;
        for (Node n : root.children) {
            maxChildDepth = Math.max(maxChildDepth, maxDepth(n));
        }
        return maxChildDepth + 1;
    }
}

复杂度分析：

  • 时间复杂度：O(n)，其中n为N叉树节点的个数。每个节点在递归中只被遍历一次。
  • 空间复杂度：O(height)，其中height表示N叉树的高度。递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于N叉树的高度。
努力努力再努力@_@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【刷题】Java 代码随想录 + java 数据结构
weixin_43147335的博客
09-13 329
Java刷题 共勉数组数组基础704. 二分查找题解想法 我是按照代码随想录的顺序刷的，github地址，看到记得给个star 刷题顺序 数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构 数组 数组基础 数组是存放在连续内存空间上的相同类型数据的集合。 数组的元素是不能删的，只能覆盖。 在java中， 二维数组的每一行头结点的地址是没有规则的，更谈不上连续。 704. 二分查找 题解
代码随想录 Day14 二叉树
02-07
二叉树的原理以及实现代码
【代码随想录】数组专栏（Java）
一舟的博客
11-04 457
由于是非递减的顺序，可以考虑二分法。在第一次找到target时，向左右探测。在左边和右边分别执行二分法找到target后返回下标。//左边 arr [ 1 ] = search2(nums , target , 1);//右边 return arr;//探测左边 right = middle - 1;} else {//探测右边 left = middle + 1;} else {}
代码随想录——数组（Java）
weixin_52150845的博客
03-25 168
记录一下自己刷代码随想录的过程，希望能坚持下去，思路、代码均来自于代码随想录。二分法-双指针法-滑动窗口-循环不变量重点学会双指针的思想！
【代码随想录】回溯算法专栏（java版本）
码农研究僧的博客
04-08 3146
总结回溯算法的题型 按照规模将其题型都熟练掌握 学习的链接大框架为： 回溯算法理论基础 LinkedList sonlist=new LinkedList(); 双向链表可以删除最前或者添加最前的节点，删除的时候通过removeLast(); List sonlist=new ArrayList(); 单链表只能添加，或者删除，删除的时候通过remove（下标值）
【代码随想录】动态规划专栏（java版本含注释）
码农研究僧的博客
04-30 1458
该算法专栏主要补充一下动态规划的知识点 主要跟的up主，链接如下： 动态规划理论基础
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录-大厂八股文稀有资源好几百页
04-19
付费渠道买的，请珍惜
代码随想录刷题笔记（java）
qq_41959609的博客
04-14 810
代码随想录刷题笔记-java-数组篇1
【代码随想录】贪心算法专栏（java版本含注释）
码农研究僧的博客
05-05 1339
所谓的贪心算法，就是局部最优到全局最优 关于该算法的学习路线如下： 代码随想录的贪心算法路线
代码随想录 字符串 Java
guliguliguliguli的博客
05-23 525
假设原字符串S是由子串s重复N次而成的，则S+S则有子串s重复2N次，那么现在有S=Ns，S+S=2Ns，其中N>=2。我的思路：2k个字符为一组，先将前k个字符（或者不足k个字符）添加到StringBuilder中，然后调用reverse()方法，然后再将后k个字符（或者不足2k个字符）添加到StringBuilder中，最后在将这一组作为一个整体，添加到答案中。在不同的编程语言中，这些函数是不一样的，主要的差别是有些语言的字符串不可变（如Python、Java），有些语言的字符串可变（如C++）。
代码随想录 回溯算法 Java
guliguliguliguli的博客
06-22 457
文章目录组合（*中等）77. 组合（*中等）17. 电话号码的字母组合（中等）39. 组合总和（中等）40. 组合总和II（中等）216. 组合总和|||分割（*中等）131. 分割回文串（*中等）93. 复制IP地址子集（中等）78. 子集（中等）90. 子集II排列（中等）46. 全排列（中等）47. 全排列II棋盘问题HDU - 2553 N皇后问题（困难）51. N皇后（困难）37. 解数独其他（中等）491. 递增子序列（*困难）332. 重新安排行程 欧拉回路/欧拉通路 组合 （*中等
代码随想录-贪心算法【1】（Java）
weixin_45685902的博客
04-01 184
贪心算法
代码随想录 LeetCode链表篇 Java
guliguliguliguli的博客
05-15 413
用head表示原始链表的头节点，新的链表的第二个节点，用newHead表示新的链表的头节点，原始链表的第二个节点，则原始链表中的其余节点的头节点是newHead.next。如果temp的后面没有节点或者只有一个节点，则没有更多的节点需要交换，因此结束交换。根据栈【先进后出】的原则，弹出栈的第n个节点就是需要删除的节点，并且，目前栈顶的节点就是待删除节点的前驱节点。如果链表中至少有两个节点，则在两两交换链表中的节点之后，原始链表的头节点编程新的链表的第二个节点，原始链表的第二个节点变成新的链表的头节点。
代码随想录——Java刷题记录
Kixuan214的博客
11-06 144
代码随想录Java刷题记录（更新中）
代码随想录 二叉树 Java（二）
guliguliguliguli的博客
06-13 659
文章目录（*中等）222. 完全二叉树的节点个数（*简单）110. 平衡二叉树（*简单）257. 二叉树的所有路径（简单）404. 左叶子之和（简单）513. 找树左下角的值（简单）112. 路径总和由第112题 二叉树 递归 小结（中等）113. 路径总和II（*中等）106. 从中序与后序遍历序列构造二叉树（中等）105. 从前序与中序遍历序列构造二叉树（中等）654. 最大二叉树（简单）617. 合并二叉树（简单）700. 二叉搜索树中的搜索（中等）98. 验证二叉搜索树（简单）530. 二叉搜索树的
二叉树 java代码
最新发布
05-27
以下是二叉树的Java代码示例： ``` class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } public class BinaryTree { private TreeNode root; public BinaryTree(int...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值