2024华为OD试题及答案-A069-创建二叉树

最新推荐文章于 2024-08-24 17:17:32 发布

NB哄哄闯天下

最新推荐文章于 2024-08-24 17:17:32 发布

阅读量684

点赞数 14

分类专栏：华为OD试题及答案文章标签：华为od java 算法

本文链接：https://blog.csdn.net/2401_86417859/article/details/141089006

版权

华为OD试题及答案专栏收录该内容

77 篇文章 5 订阅

订阅专栏

题目描述

请按下列描述构建一颗二叉树，并返回该树的根节点：

1、先创建值为-1的根结点，根节点在第0层;

2、然后根据operations依次添加节点： operations[i] = [height, index] 表示对第 height 层的第index 个节点node，添加值为 i 的子节点：

若node 无「左子节点」，则添加左子节点;
若node 有「左子节点」，但无「右子节点」，则添加右子节点；
否则不作任何处理。

height、index 均从0开始计数；

index 指所在层的创建顺序。

注意：

输入用例保证每次操作对应的节点已存在；
控制台输出的内容是根据返回的树根节点，按照层序遍历二叉树打印的结果。

输入描述

operations

输出描述

根据返回的树根节点，按照层序遍历二叉树打印的结果

备注

1 <= operations.length <= 100
operations[i].length == 2
0 <= operations[i][0] < 100
0 <= operations[i][1] < 100

用例

输入

[[0, 0], [0, 0], [1, 1], [1, 0], [0, 0]]

输出

[-1, 0, 1, 3, null, 2]

说明

首个值是根节点的值，也是返回值；

null 表示是空节点，此特殊层序遍历会遍历有值节点的 null 子节点

输入

[[0, 0], [1, 0], [1, 0], [2, 1], [2, 1], [2, 1], [2, 0], [3, 1], [2, 0]]

输出

[-1, 0, null, 1, 2, 6, 8, 3, 4, null, null, null, null, null, null, 7]

说明

首个值是根节点的值，也是返回值；

null 表示是空节点，此特殊层序遍历会遍历有值节点的 null 子节点

解题思路分析

这道题目要求我们根据一系列的操作构建一棵二叉树，并在构建完成后，输出该树的层序遍历结果。我们可以通过以下步骤来解决这个问题：

树的结构定义：
- 首先定义树的节点结构，每个节点有一个值和指向左右子节点的指针。
树的构建：
- 初始化根节点，根节点的值为1。
- 根据给定的 operations，依次向树中添加节点。每个操作由两个参数组成：height 和 index，分别表示在树的第 height 层的第 index 个节点上，添加一个新的子节点。我们需要按顺序判断并添加新的节点。
层序遍历：
- 在树构建完成后，使用层序遍历（广度优先搜索）的方法输出树的节点值。
注意事项：
- 每次操作中的 height 和 index 都确保节点存在，因此我们不需要额外检查。
- 添加子节点时，如果左右子节点都存在，则不进行任何操作。

C++ 代码实现

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void levelOrder(TreeNode* root) {
    if (!root) return;

    queue<TreeNode*> q;
    q.push(root);

    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        cout << node->val << " ";
        if (node->left) q.push(node->left);
        if (node->right) q.push(node->right);
    }
    cout << endl;
}

int main() {
    vector<vector<int>> operations = {
        {0, 0}, {1, 0}, {1, 0}, {2, 0}, {2, 1}, {2, 1}
    };

    vector<TreeNode*> levels[100];
    TreeNode* root = new TreeNode(1);
    levels[0].push_back(root);

    for (int i = 0; i < operations.size(); ++i) {
        int height = operations[i][0];
        int index = operations[i][1];
        TreeNode* node = levels[height][index];

        TreeNode* newNode = new TreeNode(i + 2);
        if (!node->left) {
            node->left = newNode;
        } else if (!node->right) {
            node->right = newNode;
        }
        levels[height + 1].push_back(newNode);
    }

    levelOrder(root);

    return 0;
}

Python 代码实现

from collections import deque

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def level_order(root):
    if not root:
        return
    queue = deque([root])
    while queue:
        node = queue.popleft()
        print(node.val, end=" ")
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    print()

def main():
    operations = [
        [0, 0], [1, 0], [1, 0], [2, 0], [2, 1], [2, 1]
    ]
    
    levels = [[] for _ in range(100)]
    root = TreeNode(1)
    levels[0].append(root)

    for i, op in enumerate(operations):
        height, index = op
        node = levels[height][index]

        new_node = TreeNode(i + 2)
        if not node.left:
            node.left = new_node
        elif not node.right:
            node.right = new_node
        levels[height + 1].append(new_node)

    level_order(root)

if __name__ == "__main__":
    main()