代码随想录算法训练营第十五天：二叉树-层序遍历、226.翻转二叉树、101. 对称二叉树

_Cyhui

已于 2023-09-08 20:09:06 修改

阅读量52

点赞数

文章标签：算法数据结构

于 2023-09-08 20:08:23 首次发布

本文链接：https://blog.csdn.net/qq_43173942/article/details/132766862

版权

day15：二叉树-层序遍历、226.翻转二叉树、101. 对称二叉树

层序遍历（广度优先搜索）

实现思路

使用二叉树本身的数据结构是无法实现层序遍历的，原因是：

层序遍历要求按照从上到下、从左到右的顺序逐层访问节点。
二叉树的数据结构描述的是节点之间的父子关系，并没有办法对同级的节点进行访问，无法满足层序遍历的要求。

因此，我们需要借助另一种数据结构——队列，来辅助实现，队列用于保存每一层里面遍历过的元素。

队列模拟过程

以下面这棵二叉树为例：要按照从上往下，从左往右的原则依次遍历二叉树

在这里插入图片描述

1、开始遍历第一层：将根节点6入列，因为第一层只有根节点6，所以记录队列的size为1。

注：size用于记录每一层的元素数量，方便确认这一层的遍历中，要从队列中弹出几个元素，具体例子请看下面的步骤。

2、处理第一层：队列中的size为1，所以这次只要弹出1个元素，也就是把根节点6弹出，此时size变回0。

3、遍历第二层：将根节点6的左孩子4和右孩子7入列，第二层只有两个节点，所以记录此时队列的size为2。

4、处理第二层：将节点4出列，然后将节点4的左孩子1和右孩子3入列，size–。

注意，此时由于第二层的节点还没遍历完，所以进行的操作是size–，此时size为1，说明此次遍历中，还有一个节点未处理，也就是节点7还未出列。

5、接着将节点7出列，将节点7的左孩子和右孩子入列，size–，此时size为0，说明第二层的节点已经全部遍历完毕，也就是说，队列中已经有了第三层的所有节点，第三层有4个节点，所以size为4。

6、重复上述步骤，第三层节点依次出列，直至二叉树都遍历完毕结束。

例题：

102. 二叉树的层序遍历

public class Solution {
    public IList<IList<int>> LevelOrder(TreeNode root) {
        IList<IList<int>> result = new List<IList<int>>();
        if(root == null)
            return result;
        
        Queue<TreeNode> queue = new Queue<TreeNode>();
        queue.Enqueue(root);
        
        while(queue.Count > 0)
        {
            int size = queue.Count;
            IList<int> cur = new List<int>();

            for(int i = 0; i < size; i++)
            {
                TreeNode node = queue.Dequeue();
                cur.Add(node.val);

                if(node.left != null)
                    queue.Enqueue(node.left);
                if(node.right != null)
                    queue.Enqueue(node.right);
            }
            result.Add(cur);
        }
        return result;
    }
}

107.二叉树的层次遍历II

本题是自底向上的遍历，但是每层的节点顺序不变，所以基本思路和上面的102题一样，只不过借助栈来实现逆序保存

public class Solution {
    public IList<IList<int>> LevelOrderBottom(TreeNode root) {
        IList<IList<int>> result = new List<IList<int>>();
        if(root == null)
            return result;

        Queue<TreeNode> queue = new Queue<TreeNode>();
        Stack<IList<int>> stack = new Stack<IList<int>>();

        queue.Enqueue(root);

        while(queue.Count > 0)
        {
            int size = queue.Count;
            IList<int> cur = new List<int>();

            for(int i = 0; i < size; i++)
            {
                TreeNode node = queue.Dequeue();
                cur.Add(node.val);
                if(node.left != null)
                    queue.Enqueue(node.left);
                if(node.right != null)
                    queue.Enqueue(node.right);
            }
            stack.Push(cur);//当前节点的值入栈
        }
        while(stack.Count > 0)
        {
            result.Add(stack.Pop());//栈先入后出，实现逆序的结果
        }
        return result;

    }
}

LeetCode 226.翻转二叉树

题目链接：

226.翻转二叉树

文章讲解：

https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html

视频讲解：

https://www.bilibili.com/video/BV1sP4y1f7q7

思路和解法：

递归解法

牢记递归三部曲

前序遍历

1、确定递归函数的参数和返回值

返回值：题目要求返回根节点，那就是TreeNode

参数：传入的根节点，也就是root

2、确定终止条件

碰到空节点的时候终止遍历

3、确定单层递归的逻辑

前序遍历中左右：

中：此节点就是要处理的节点，处理的是交换这个节点的两个孩子

左：遍历的方向，要向左遍历

右：遍历的方向，要向右遍历

public class Solution {
    public TreeNode InvertTree(TreeNode root) {
        if(root == null)
            return root;
        (root.left, root.right) = (root.right, root.left);//中
        InvertTree(root.left);  //左
        InvertTree(root.right); //右
        return root;
    }
}

后序遍历

public class Solution {
    public TreeNode InvertTree(TreeNode root) {
        if(root == null)
            return root;
        
        InvertTree(root.left);  //左
        InvertTree(root.right); //右
        (root.left, root.right) = (root.right, root.left);//中
        return root;
    }
}

中序遍历

普通的中序遍历是不行的，**因为使用递归的中序遍历，某些节点的左右孩子会翻转两次。**如果要避免这种状态，就需要再遍历一次进行翻转。

public class Solution {
    public TreeNode InvertTree(TreeNode root) {
        if(root == null)
            return root;
        
        InvertTree(root.left);  //左
        (root.left, root.right) = (root.right, root.left);//中
        //右，因为在翻转中节点后，已经翻转过的左子节点被翻转到右边了，没被翻转的反而到了左边，左移这里要再次传入左节点
        InvertTree(root.left); 
        return root;
    }
}

LeetCode 101.对称二叉树

题目链接：

101. 对称二叉树

文章讲解：

https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html

视频讲解：

https://www.bilibili.com/video/BV1ue4y1Y7Mf

思路和解法：

递归

如果根节点为空（null），则认为它是对称的。
如果根节点不为空，但它的左子树和右子树中只有一个为空，那么它不是对称的。
否则，我们比较左子树的左子树和右子树的右子树，以及左子树的右子树和右子树的左子树是否镜像对称。这是一个递归的过程。

public class Solution {
    public bool IsSymmetric(TreeNode root) {
        if (root == null)
            return true;

        return IsMirror(root.left, root.right);
    }

    private bool IsMirror(TreeNode left, TreeNode right)
    {
        if (left == null && right == null)
            return true;
        if (left == null || right == null)
            return false;
    
        // 检查左子树的左子树和右子树的右子树，以及左子树的右子树和右子树的左子树是否镜像对称
        return (left.val == right.val) && IsMirror(left.left, right.right) && IsMirror(left.right, right.left);
    }
}

left == null || right == null)
return false;

    // 检查左子树的左子树和右子树的右子树，以及左子树的右子树和右子树的左子树是否镜像对称
    return (left.val == right.val) && IsMirror(left.left, right.right) && IsMirror(left.right, right.left);
}

}