代码随想录day14|104二叉树最大深度111二叉树最小深度222完全二叉树节点个数|01笔记

麟一01
94 阅读1分钟

  • 104二叉树最大深度

  • 代码随想录 (programmercarl.com)

  • 第一印象

  • 使用层序遍历，并且设定一个计数器，可以在每次更新容器时是计数器加一，最后返回计数器的值。

  • 讲解观后感

  • 递归方法的前序和后序对应了求二叉树的深度和高度。
  • 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
  • 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）.所以要单独讨论左右子树单独为空的情况。

  • 解题代码

  • 递归后序
  •     /**
     * Definition for a binary tree node.
     * type TreeNode struct {
     *     Val int
     *     Left *TreeNode
     *     Right *TreeNode
     * }
     */
    func maxDepth(root *TreeNode) int {
        return getHeight(root)
    }
    
    func getHeight(node *TreeNode) int {
        if node==nil {
            return 0
        }
        lh := getHeight(node.Left)
        rh := getHeight(node.Right)
        return 1 + getMax(lh, rh)
    }
    
    func getMax(x int, y int) int {
        if x > y {
            return x
        } else {
            return y
        }
    }
  • 层序
  •     /**
     * Definition for a binary tree node.
     * type TreeNode struct {
     *     Val int
     *     Left *TreeNode
     *     Right *TreeNode
     * }
     */
    func maxDepth(root *TreeNode) int {
        depth := 0
        st := list.New()
        if root==nil {
            return depth
        }
    
        st.PushBack(root)
    
        for st.Len()!=0 {
            depth++
            lenS := st.Len()
            for i:=0;i<lenS;i++ {
                node := st.Remove(st.Front()).(*TreeNode)
                if node.Left!=nil {
                    st.PushBack(node.Left)
                }
                if node.Right!=nil {
                    st.PushBack(node.Right)
                }
            }
        }
        return depth
    
    }

  • 111二叉树的最小深度

  • 代码随想录 (programmercarl.com)

  • 第一印象

  • 可以使用层序遍历，方法同求最大深度时来计数深度，当遇到左右子节点都为nil时结束计数。

  • 讲解观后感

  • 迭代法使用时要注意不可以简单的直接返回两个子节点的较小值，因为当其中一个节点为空时会判定为最小，而最小深度不在这里。

  • 解题代码

  • 层序
  •     func minDepth(root *TreeNode) int {
        depth := 0
        st := list.New()
        if root==nil {
            return depth
        }
    
        st.PushBack(root)
        for st.Len()!=0 {
            depth++
            lenS := st.Len()
            for i:=0;i<lenS;i++ {
                node := st.Remove(st.Front()).(*TreeNode)
                if node.Left==nil && node.Right==nil {
                    return depth
                }
                if node.Left!=nil {
                    st.PushBack(node.Left)
                }
                if node.Right!=nil {
                    st.PushBack(node.Right)
                }
            }
        }
        return depth
    }
  • 后序递归
  •     func min(a, b int) int {
        if a < b {
            return a;
        }
        return b;
    }
    // 递归
    func minDepth(root *TreeNode) int {
        if root == nil {
            return 0;
        }
        if root.Left == nil && root.Right != nil {
            return 1 + minDepth(root.Right);
        }
        if root.Right == nil && root.Left != nil {
            return 1 + minDepth(root.Left);
        }
        return min(minDepth(root.Left), minDepth(root.Right)) + 1;
    }

  • 222完全二叉树的节点个数

  • 代码随想录 (programmercarl.com)

  • 第一印象

  • 可以按照普通二叉树的迭代法进行统计。dfs或者bfs都可以。

  • 讲解观后感

  • 解题代码

  • 后序递归
  •     //本题直接就是求有多少个节点，无脑存进结果变量就行了。
    func countNodes(root *TreeNode) int {
        if root == nil {
            return 0
        }
        res := 1
        if root.Right != nil {
            res += countNodes(root.Right)
        }
        if root.Left != nil {
            res += countNodes(root.Left)
        }
        return res
  • 层序遍历迭代
  •     func countNodes(root *TreeNode) int {
        if root == nil {
            return 0
        }
        q := list.New()
        q.PushBack(root)
        res := 0
        for q.Len() > 0 {
            n := q.Len()
            for i := 0; i < n; i++ {
                node := q.Remove(q.Front()).(*TreeNode)
                if node.Left != nil {
                    q.PushBack(node.Left)
                }
                if node.Right != nil {
                    q.PushBack(node.Right)
                }
                res++
            }
        }
        return res 
    }
  • 利用完全二叉树特性
  •     func countNodes(root *TreeNode) int {
        if root == nil {
            return 0
        }
        leftH, rightH := 0, 0
        leftNode := root.Left
        rightNode := root.Right
        for leftNode != nil {
            leftNode = leftNode.Left
            leftH++
        }
        for rightNode != nil {
            rightNode = rightNode.Right
            rightH++
        }
        if leftH == rightH {
            return (2 << leftH) - 1
        }
        return countNodes(root.Left) + countNodes(root.Right) + 1
    }
  • C/C++ 左移＜＜, 右移＞＞作用_c++左移右移用途_慕木子的博客-CSDN博客
avatar
文章
阅读
粉丝