leetcode
leetcode 2051 ~ 2100
反转二叉树的奇数层

反转二叉树的奇数层

难度:

标签:

题目描述

给你一棵 完美 二叉树的根节点 root ,请你反转这棵树中每个 奇数 层的节点值。

  • 例如,假设第 3 层的节点值是 [2,1,3,4,7,11,29,18] ,那么反转后它应该变成 [18,29,11,7,4,3,1,2]

反转后,返回树的根节点。

完美 二叉树需满足:二叉树的所有父节点都有两个子节点,且所有叶子节点都在同一层。

节点的 层数 等于该节点到根节点之间的边数。

 

示例 1:

输入:root = [2,3,5,8,13,21,34]
输出:[2,5,3,8,13,21,34]
解释:
这棵树只有一个奇数层。
在第 1 层的节点分别是 3、5 ,反转后为 5、3 。

示例 2:

输入:root = [7,13,11]
输出:[7,11,13]
解释: 
在第 1 层的节点分别是 13、11 ,反转后为 11、13 。 

示例 3:

输入:root = [0,1,2,0,0,0,0,1,1,1,1,2,2,2,2]
输出:[0,2,1,0,0,0,0,2,2,2,2,1,1,1,1]
解释:奇数层由非零值组成。
在第 1 层的节点分别是 1、2 ,反转后为 2、1 。
在第 3 层的节点分别是 1、1、1、1、2、2、2、2 ,反转后为 2、2、2、2、1、1、1、1 。

 

提示:

  • 树中的节点数目在范围 [1, 214]
  • 0 <= Node.val <= 105
  • root 是一棵 完美 二叉树

代码结果

运行时间: 129 ms, 内存: 20.4 MB


/*
题目思路:
1. 使用流(Stream)处理节点。
2. 利用广度优先搜索(BFS)层序遍历整棵树。
3. 对于每一个奇数层的节点,反转该层的节点值。
4. 返回反转后的树的根节点。
*/

import java.util.*;
import java.util.stream.*;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int val) { this.val = val; }
}

public class Solution {
    public TreeNode reverseOddLevels(TreeNode root) {
        if (root == null) return null;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        boolean isOddLevel = false;

        while (!queue.isEmpty()) {
            List<TreeNode> currentLevel = queue.stream().collect(Collectors.toList());
            queue.clear();
            currentLevel.forEach(node -> {
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            });

            if (isOddLevel) {
                IntStream.range(0, currentLevel.size() / 2).forEach(i -> {
                    int temp = currentLevel.get(i).val;
                    currentLevel.get(i).val = currentLevel.get(currentLevel.size() - 1 - i).val;
                    currentLevel.get(currentLevel.size() - 1 - i).val = temp;
                });
            }

            isOddLevel = !isOddLevel;
        }

        return root;
    }
}

解释

方法:

此题解采用层序遍历的方法来访问和修改完美二叉树的奇数层节点。首先,使用一个队列来存储当前层的所有节点。通过循环,每次都将当前层的所有子节点添加到下一层的队列中。对于每一层,如果是奇数层(从0开始计数,所以实际的奇数层在代码中用偶数1表示),则在队列中将该层的节点值进行反向交换,从而实现每个奇数层的节点值反转。层序遍历继续,直到队列中的节点没有子节点为止。

时间复杂度:

O(n)

空间复杂度:

O(n)

代码细节讲解

🦆
为什么在处理队列时,只检查队列中第一个节点是否有左子节点来判断是否继续循环?
在完美二叉树中,如果一个节点有子节点,那么它的所有同层节点也必然有子节点。因此,检查队列中第一个节点是否有左子节点足以判断整个层是否有子节点。这样的检查简化了逻辑,提高了代码的效率。
🦆
你是怎么确定在层序遍历过程中,哪些层是奇数层的?
通过引入一个变量`level`来跟踪当前层的奇偶性。初始时`level`设为1,表示下一层(第一层)是奇数层。每处理完一层后,使用`level ^= 1`操作来切换`level`的值,从而跟踪接下来的层是奇数还是偶数层。
🦆
反转节点值时,为什么选择从列表的两头向中间交换值?
从列表两端向中间交换值是实现列表元素反转的一个有效方法。这种方式确保了在单次遍历中完成整层节点值的反转,节省时间和空间。从两端向中间交换直到中点,确保了每个节点的值只被交换一次。
🦆
在交换节点值时,使用的是`x.val, y.val = y.val, x.val`这样的赋值方式,这种方式有没有可能在某些编程语言中出现问题?
在Python中,`x.val, y.val = y.val, x.val`是一种常用的并且安全的元素交换方式,它利用了Python的元组解包和打包特性。然而,在一些不支持多重赋值或元组打包解包的编程语言中,这种直接交换的写法可能会导致错误或需要额外的临时变量来完成交换。例如,在C或Java中,通常需要一个临时变量来安全地交换两个变量的值。

相关问题