代码随想录算法训练营第十五天|树的层序遍历|翻转二叉树|对称二叉树-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_18563269/article/details/132670938

文章讲述了在二叉树和N叉树的层序遍历基础上，涉及到了二叉树的右视图、层平均值计算、填充next指针、以及二叉树的翻转和轴对称性检查等技术，展示了如何通过C#实现这些操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

层序遍历

199.二叉树的右视图

给定一个二叉树的根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例一：请添加图片描述
输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

思路：通过层序遍历，获得每层中最后一个元素，即为右视图中看到的元素。
c#代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public IList<int> RightSideView(TreeNode root) {
        var list = new List<int>();
        if(root == null) return list;
        var queue = new Queue<TreeNode>();
        queue.Enqueue(root);
        while(queue.Count > 0)
        {
            var itemSt = new Stack<int>();
            int len = queue.Count;
            while(len > 0)
            {
                var temp = queue.Dequeue();
                itemSt.Push(temp.val);
                if(temp.left != null) queue.Enqueue(temp.left);
                if(temp.right != null) queue.Enqueue(temp.right);
                len--;
            }
            list.Add(itemSt.Pop());
        }
        return list;
    }
}

637.二叉树的层平均值

题目：给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。
示例一：请添加图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

思路：遍历出每层的元素的和，再求出平均值。

c#代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public IList<double> AverageOfLevels(TreeNode root) {
        var list = new List<double>();
        if(root == null) return list;
        var queue = new Queue<TreeNode>();
        queue.Enqueue(root);
        while(queue.Count > 0)
        {
            int len = queue.Count;
            //每层中的元素
            var itemList = new List<double>();
            while(len > 0)
            {
                var temp = queue.Dequeue();
                itemList.Add(temp.val);
                if(temp.left != null) queue.Enqueue(temp.left);
                if(temp.right != null) queue.Enqueue(temp.right);
                len--;
            }
            len = itemList.Count;
            double sum = 0;
            foreach(double i in itemList)
            {
                sum += i;
            }
            sum = sum/itemList.Count;
            list.Add(sum);
        }
        return list;
    }
}

429.N 叉树的层序遍历

题目：给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
示例一：请添加图片描述

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

思路：同二叉树的层序遍历一样，只是将二叉树中添加左右子树的步骤改成添加当前结点的所有子树。
c#代码：

/*
// Definition for a Node.
public class Node {
    public int val;
    public IList<Node> children;

    public Node() {}

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

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

public class Solution {
    public IList<IList<int>> LevelOrder(Node root) {
        var list = new List<IList<int>>();
        if(root == null) return list;
        var queue = new Queue<Node>();
        queue.Enqueue(root);
        while(queue.Count > 0)
        {
            int len = queue.Count;
            var itemList = new List<int>();
            while(len > 0)
            {
                var temp = queue.Dequeue();
                itemList.Add(temp.val);
                // 将当前结点所有子结点添加进队列
                foreach(Node i in temp.children)
                {
                    queue.Enqueue(i);
                }
                len--;
            }
            list.Add(itemList);
        }
        return list;
    }
}

515.在每个树行中找最大值

题目：给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
示例一：请添加图片描述

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

思路：通过层序遍历，在每层中找到最大值即可。
c#代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public IList<int> LargestValues(TreeNode root) {
        var list = new List<int>();
        if(root == null) return list;
        var queue = new Queue<TreeNode>();
        queue.Enqueue(root);
        while(queue.Count>0)
        {
            int len = queue.Count;
            var itemList = new List<int>();
            while(len > 0)
            {
                var temp = queue.Dequeue();
                itemList.Add(temp.val);
                if(temp.left != null) queue.Enqueue(temp.left);
                if(temp.right != null) queue.Enqueue(temp.right);
                len--;
            }
            //得到每层中的最大值
            var maxVal = itemList.Max();
            list.Add(maxVal);
        }
        return list;
    }
}

116.填充每个节点的下一个右侧节点指针

题目：给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。

示例 1：请添加图片描述

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，‘#’ 标志着每一层的结束。

思路：通过遍历每一层的元素，让每一层中的当前元素指向下一个元素，最后一个元素指向null；

c#代码：

/*
// Definition for a Node.
public 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;
    }
}
*/

public class Solution {
    public Node Connect(Node root)
    {
        if(root==null)return root;
        Queue<Node> que=new Queue<Node>();
        que.Enqueue(root);
        while(que.Count>0)
        {
            int len=que.Count;
            while(len>0)
            {
                Node cur=que.Dequeue();
                if(len==1)
                {
                    cur.next=null;
                }
                else
                {
                    cur.next=que.Peek();
                }
                if(cur.left!=null)que.Enqueue(cur.left);
                if(cur.right!=null)que.Enqueue(cur.right);
                
                len--;
            }
        }
        return root;
    }
}

104. 二叉树的最大深度

题目：给定一个二叉树 root ，返回其最大深度。
二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。
示例一：请添加图片描述

输入：root = [3,9,20,null,null,15,7]
输出：3

思路：层序遍历，在遍历到每一层时深度加1.
C#代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public int MaxDepth(TreeNode root) {
        int depth = 0;
        if(root == null) return depth;
        var queue = new Queue<TreeNode>();
        queue.Enqueue(root);
        while(queue.Count > 0)
        {
            int len = queue.Count;
            while(len > 0)
            {
                var temp = queue.Dequeue();
                if(temp.left != null) queue.Enqueue(temp.left);
                if(temp.right != null) queue.Enqueue(temp.right);
                len--;
            } 
            depth++;
        }
        return depth;
    }
}

111.二叉树的最小深度

题目：给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例一：请添加图片描述

输入：root = [3,9,20,null,null,15,7]
输出：2

思路：层序遍历，当遍历到当前元素没有子节点时，说明当前层中有叶子结点，即最小路径。

C#代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public int MinDepth(TreeNode root) {
        int depth = 0;
        if(root == null) return depth;
        var qu = new Queue<TreeNode>();
        qu.Enqueue(root);
        while(qu.Count > 0)
        {
            int len = qu.Count;
            depth++;
            while(len > 0)
            {
                var node = qu.Dequeue();
                if (node.left == null && node.right == null)
                {
                    return depth;
                }
                if (node.left != null)
                {
                    qu.Enqueue(node.left);
                }
                if (node.right != null)
                {
                    qu.Enqueue(node.right);
                }
                len--;
            }
        }
        return depth;
    }
}

226. 翻转二叉树

题目：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例一：请添加图片描述

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

思路：通过递归前序、后序遍历，在处理中间结点时，交换它的左子树和右子树的位置，即可达到翻转。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    //递归三部曲：
    //1. 确定参数和返回值
    //2. 确定终止条件
    //3. 处理逻辑
    public TreeNode InvertTree(TreeNode root) {
        if(root == null) return root;
        //交换左右子树
        var temp = root.left;
        root.left = root.right;
        root.right = temp;
        InvertTree(root.left);
        InvertTree(root.right);
        return root;
    }
}

101. 对称二叉树

题目：给你一个二叉树的根节点 root ，检查它是否轴对称。
示例一：请添加图片描述

输入：root = [1,2,2,3,4,4,3]
输出：true

思路：通过递归后序遍历，判断root结点的左子树和右子树中各个结点的几种情况。
在这里插入图片描述

C#代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    public bool IsSymmetric(TreeNode root) {
        return fun1(root.left,root.right);
    }
    public bool fun1(TreeNode left, TreeNode right)
    {
        if(left == null && right != null) return false;
        if(left != null && right == null) return false;
        if(left == null && right == null) return true;
        if(left.val != right.val) return false;![请添加图片描述](https://img-blog.csdnimg.cn/0180bb2ce1a5411ab9987bde6a3418b2.png)
		//结点外侧
        bool o = fun1(left.left,right.right);
        //结点内侧
        bool i = fun1(left.right,right.left);
        return o&&i;
    }
}