【华为OD-E卷 - 评论转换输出 100分（python、java、c++、js、c）】
题目
在一个博客网站上，每篇博客都有评论。
每一条评论都是一个非空英文字母字符串。
评论具有树状结构，除了根评论外，每个评论都有一个父评论。
当评论保存时，使用以下格式：
首先是评论的内容； 然后是回复当前评论的数量。 最后是当前评论的所有了评论。(子评论使用相同的格式嵌套存储) 所有元素之间都用单个逗号分隔。
例如，如果评论如下：
第一条评论是"helo,2,ok,0,bye,0"，第二条评论是"test,0"，第三条评论是"one,1,two,1,a,0"。
所有评论被保存成"hello,2,ok,0.bye,0,test,0,one,1,two,1,a,0"。
对于上述格式的评论，请以另外一种格式打印：
首先打印评论嵌套的最大深度。 然后是打印n行，第 i (1 ≤ i ≤ n) 行对应于嵌套级别为 i 的评论 (根评论的嵌套级别为1)。 对于第 i 行，嵌套级别为的评论按照它们出现的顺序打印，用空格分隔开
输入描述
一行评论。由英文字母、数字和英文逗号组成。
保证每个评论都是由英文字符组成的非空字符串。
每个评论的数量都是整数 (至少由一个数字组成)。
整个字符串的长度不超过10^6。
给定的评论结构保证是合法的
输出描述
- 按照给定的格式打印评论。对于每一级嵌套，评论应该按照输入中的顺序打印
用例
用例一：
输入：
hello,2,ok,0,bye,0,test,0,one,1,two,1,a,0
- 1
输出：
3
hello test one
ok bye two
a
- 1
- 2
- 3
- 4
用例二：
输入：
A,5,A,0,a,0,A,0,a,0,A,0
- 1
输出：
2
A
A a A a A
- 1
- 2
- 3
用例三：
输入：
A,3,B,2,C,0,D,1,E,0,F,1,G,0,H,1,I,1,J,0,K,1,L,0,M,2,N,0,O,1,P,0
- 1
输出：
4
A K M
B F H L N O
C D G I P
E J
- 1
- 2
- 3
- 4
- 5
python解法
- 解题思路：
- 该代码的目的是根据输入的字符串构建一棵多叉树，并按层级输出每层的节点。输入的字符串包含评论内容和每个评论的子评论数量。程序使用递归方法将评论及其子评论按层级组织到树结构中，并最终输出每一层的评论内容。
具体步骤如下：
输入处理：
输入的字符串通过逗号分隔，每个评论后面紧跟着一个数字，表示该评论的子评论数量。
例如输入 “A,2,B,0,C,1,D,0” 表示：
A 有 2 个子评论：B 和 C。
B 没有子评论。
C 有 1 个子评论：D。
D 没有子评论。
树的构建：
使用 tree 列表存储每一层的评论，tree[0] 为第一层评论，tree[1] 为第二层评论，以此类推。
使用 queue 队列来依次处理评论和子评论数量。
递归函数 recursive() 处理子评论，逐层递归构建树。
结果输出：
最终输出树的层数以及每一层的评论内容
def get_result(comments):
tree = [] # 用于存储树的层级结构，每一层是一个列表
queue = comments.split(",") # 将输入的字符串按逗号分割，形成队列
level = 1 # 初始化层级，从1开始
# 处理队列中的评论
while queue:
comment = queue.pop(0) # 取出当前评论
if len(tree) < level:
tree.append([]) # 如果当前层级不存在，初始化该层
tree[0].append(comment) # 将第一个评论加入第一层
child_count = int(queue.pop(0)) # 取出当前评论的子评论数量
# 递归处理子评论
recursive(queue, level + 1, child_count, tree)
print(len(tree)) # 输出树的层数
for level_nodes in tree:
print(" ".join(level_nodes)) # 输出每一层的评论内容
def recursive(queue, level, child_count, tree):
"""
递归处理子评论
:param queue: 剩余的评论队列
:param level: 当前处理的层级
:param child_count: 当前评论的子评论数量
:param tree: 树的结构，按层级存储评论
"""
for _ in range(child_count):
comment = queue.pop(0) # 取出子评论
if len(tree) < level:
tree.append([]) # 如果当前层级不存在，初始化该层
tree[level - 1].append(comment) # 将子评论加入对应的层级
count = int(queue.pop(0)) # 取出当前子评论的子评论数量
if count > 0:
recursive(queue, level + 1, count, tree) # 如果子评论还有子评论，继续递归
if __name__ == "__main__":
comments = input() # 输入评论字符串
get_result(comments)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
java解法
- 解题思路
- 该代码的目的是解析一串表示评论和子评论的字符串，构建一棵树状结构，并按层级输出每一层的评论内容。
核心思路：
输入格式：
输入是一串由逗号分隔的字符串，奇数位置表示评论内容，偶数位置表示该评论的子评论数量。
例如输入：“A,2,B,0,C,1,D,0” 表示：
A 有 2 个子评论：B 和 C。
B 没有子评论。
C 有 1 个子评论：D。
D 没有子评论。
树的构建：
使用 List 数据结构表示树的层级，每一层是一个 List。
使用 Queue 处理输入数据，逐个解析评论及其子评论数量。
递归方法 buildTree 负责构建树的层级结构。
输出结果：
输出树的层数（即层级数）。
依次输出每一层的评论内容。
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String data = scanner.nextLine(); // 从控制台读取输入数据
scanner.close();
List<List<String>> tree = processComments(data); // 处理输入数据，构建树结构
outputResult(tree); // 输出结果
}
/**
* 处理输入的评论数据，构建树的层级结构
*
* @param data 输入的字符串，包含评论和子评论数量
* @return 树的层级结构，每一层是一个字符串列表
*/
public static List<List<String>> processComments(String data) {
List<List<String>> tree = new ArrayList<>(); // 存储树的层级结构
Queue<String> queue = new LinkedList<>(); // 用于处理输入的队列
// 将输入字符串按逗号分割，加入队列
for (String part : data.split(",")) {
queue.add(part);
}
// 当队列不为空时，继续构建树
while (!queue.isEmpty()) {
buildTree(queue, 1, tree); // 从第1层开始构建
}
return tree;
}
/**
* 递归构建树的层级结构
*
* @param queue 输入数据的队列
* @param level 当前处理的层级
* @param tree 树的层级结构
*/
private static void buildTree(Queue<String> queue, int level, List<List<String>> tree) {
// 如果当前层级在树中不存在，初始化该层
if (tree.size() < level) {
tree.add(new ArrayList<>());
}
String comment = queue.poll(); // 取出当前评论
tree.get(level - 1).add(comment); // 将评论添加到对应层级
int childrenCount = Integer.parseInt(queue.poll()); // 获取子评论数量
// 递归处理子评论
for (int i = 0; i < childrenCount; i++) {
buildTree(queue, level + 1, tree);
}
}
/**
* 输出树的层级结果
*
* @param tree 树的层级结构
*/
public static void outputResult(List<List<String>> tree) {
System.out.println(tree.size()); // 输出层数
for (List<String> levelComments : tree) {
System.out.println(String.join(" ", levelComments)); // 输出每层的评论内容
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
C++解法
- 解题思路
更新中
- 1
C解法
更新中
- 1
JS解法
更新中
- 1
注意：
如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。
解题不易，如对您有帮助，欢迎点赞/收藏
评论记录：
回复评论：