zoukankan      html  css  js  c++  java
  • LeetCode 104. 二叉树的最大深度(C#实现)——二叉树,BFS,DFS,递归,迭代

    一、问题
    https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

    给定一个二叉树,找出其最大深度。
    
    二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
    
    说明: 叶子节点是指没有子节点的节点。
    
    示例:
    给定二叉树 [3,9,20,null,null,15,7],
    
        3
       / 
      9  20
        /  
       15   7
    
    返回它的最大深度 3

    二、GitHub实现:https://github.com/JonathanZxxxx/LeetCode/blob/master/MaxDepthClass.cs

      Blog:https://www.cnblogs.com/zxxxx/

    三、思路

      1、深度优先搜索,递归:对左右孩子进行DFS递归,得出最大值

      2、深度优先搜索,迭代:获取最深的节点深度。根节点和当前节点深度1入栈,每次迭代中,获取并移除栈顶元素,比较当前节点深度和当前深度,取最大值,当前节点右孩子不为空的话,将右孩子和当前节点深度加一入栈,左孩子同理

      3、广度优先搜索,迭代:记录二叉树的层数。根节点入队列,每次迭代,当前深度加一,循环当前队列长度,每次循环,获取并移队列顶元素,当前节点左孩子不为空,入队列,右孩子同理

    四、代码实现

        public class MaxDepthClass
        {
            public class TreeNode
            {
                public int val;
                public TreeNode left;
                public TreeNode right;
                public TreeNode(int x) { val = x; }
            }
    
            /// <summary>
            /// 深度优先搜索,递归
            /// </summary>
            /// <param name="root"></param>
            /// <returns></returns>
            public int MaxDepth(TreeNode root)
            {
                if (root == null) return 0;
                var left = MaxDepth(root.left);
                var right = MaxDepth(root.right);
                return Math.Max(left, right) + 1;
            }
    
            /// <summary>
            /// 广度优先搜索,迭代
            /// </summary>
            /// <param name="root"></param>
            /// <returns></returns>
            public int MaxDepthBFS(TreeNode root)
            {
                if (root == null) return 0;
                var queue = new Queue<TreeNode>();
                queue.Enqueue(root);
                var count = 0;
                while (queue.Any())
                {
                    count++;
                    var length = queue.Count;
                    for (int i = 0; i < length; i++)
                    {
                        var current = queue.Dequeue();
                        if (current.left != null) queue.Enqueue(current.left);
                        if (current.right != null) queue.Enqueue(current.right);
                    }
                }
                return count;
            }
    
            /// <summary>
            /// 深度优先搜索,迭代
            /// </summary>
            /// <param name="root"></param>
            /// <returns></returns>
            public int MaxDepthDFS(TreeNode root)
            {
                if (root == null) return 0;
                var stack = new Stack<Tuple<TreeNode, int>>();
                var depth = 0;
                stack.Push(new Tuple<TreeNode, int>(root, 1));
                while (stack.Any())
                {
                    var current = stack.Pop();
                    depth = Math.Max(depth, current.Item2);
                    if (current.Item1.right != null) stack.Push(new Tuple<TreeNode, int>(current.Item1.right, current.Item2 + 1));
                    if (current.Item1.left != null) stack.Push(new Tuple<TreeNode, int>(current.Item1.left, current.Item2 + 1));
                }
                return depth;
            }
        }
  • 相关阅读:
    11. Container With Most Water
    面试题------前端框架与其他
    python----生成器--列表推导式-----内置函数-----
    python----函数-----有参装饰器----迭代器
    python---闭包函数应用---装饰器
    python----函数-----名称空间与作用域 闭包函数
    python ----函数
    python---函数
    文件操作
    集合 文件部分操作
  • 原文地址:https://www.cnblogs.com/zxxxx/p/12157289.html
Copyright © 2011-2022 走看看