题目描述
二叉树也可以用数组来存储,给定一个数组,树的根节点的值存储在下标1,对于存储在下标N的节点,它的左子节点和右子节点分别存储在下标2*N和2*N+1,并且我们用值-1代表一个节点为空。
给定一个数组存储的二叉树,试求从根节点到最小的叶子节点的路径,路径由节点的值组成。
输入描述
输入一行为数组的内容,数组的每个元素都是正整数,元素间用空格分隔。
注意第一个元素即为根节点的值,即数组的第N个元素对应下标N,下标0在树的表示中没有使用,所以我们省略了。
输入的树最多为7层。
输出描述
输出从根节点到最小叶子节点的路径上,各个节点的值,由空格分隔,用例保证最小叶子节点只有一个。
用例
输入 | 3 5 7 -1 -1 2 4 |
---|---|
输出 | 3 7 2 |
说明 | 最小叶子节点的路径为3 7 2。 |
输入 | 5 9 8 -1 -1 7 -1 -1 -1 -1 -1 6 |
---|---|
输出 | 5 8 7 6 |
说明 | 最小叶子节点的路径为5 8 7 6,注意数组仅存储至最后一个非空节点,故不包含节点“7”右子节点的-1。 |
题目解析
- 1.
首先,我们需要找到最小叶子节点。可以通过遍历数组,找到值为非负数的最小值,该值即为最小叶子节点的值。
- 2.
然后,从根节点开始,根据数组下标关系,找到最小叶子节点的路径。具体方法是,从根节点开始,每次将当前节点的下标乘以2和2*N+1,分别表示左子节点和右子节点的下标。如果左子节点或右子节点的值小于等于当前节点的值,则继续向下遍历,直到找到最小叶子节点。
- 3.
最后,输出从根节点到最小叶子节点的路径上的各个节点的值。
JavaScript算法源码
const readline = require("readline");
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
rl.on("line", (line) => {
const arr = line.split(" ").map(Number);
let n = arr.length - 1;
// 最小叶子节点的值
let min = Infinity;
// 最小节点在数组中的索引位置
let minIdx = -1;
for (let i = n; i >= 0; i--) {
if (arr[i] !== -1 && (!arr[i * 2 + 1] || !arr[i * 2 + 2])) {
if (min > arr[i]) {
min = arr[i];
minIdx = i;
}
}
}
// path用于缓存最小叶子节点到根的路径
const path = [];
path.unshift(min);
// 从最小值节点开始向上找父节点,直到树顶
while (minIdx !== 0) {
let f = Math.floor((minIdx - 1) / 2);
path.unshift(arr[f]);
minIdx = f;
}
console.log(path.join(" "));
});
Java算法源码
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Integer[] arr = Arrays.stream(sc.nextLine().split(" ")).map(Integer::parseInt).toArray(Integer[]::new);
System.out.println(getResult(arr));
}
public static String getResult(Integer[] arr) {
int n = arr.length - 1;
int min = Integer.MAX_VALUE;
int minIdx = -1;
for (int i = n; i >= 1; i--) {
if (arr[i] != -1 && isLeafNode(arr, i)) {
if (min > arr[i]) {
min = arr[i];
minIdx = i;
}
}
}
ArrayList<Integer> path = new ArrayList<>();
path.add(min);
while (minIdx != 0) {
int f = (minIdx - 1) / 2;
path.add(arr[f]);
minIdx = f;
}
return buildPathString(path);
}
private static boolean isLeafNode(Integer[] arr, int index) {
int leftChildIndex = index * 2 + 1;
int rightChildIndex = index * 2 + 2;
return leftChildIndex > arr.length || arr[leftChildIndex] == -1 && rightChildIndex > arr.length || arr[rightChildIndex] == -1;
}
private static String buildPathString(ArrayList<Integer> path) {
StringBuilder sb = new StringBuilder();
for (int i = path.size() - 1; i >= 0; i--) {
sb.append(path.get(i)).append(" ");
}
return sb.toString().trim();
}
}
Python算法源码
import sys
# 输入获取
arr = list(map(int, input().split()))
# 算法入口
def getResult(arr):
minV = sys.maxsize
minIdx = -1
n = len(arr) - 1
for i in range(n, 0, -1):
if arr[i] != -1:
if i * 2 + 1 <= n and arr[i * 2 + 1] != -1:
continue
if i * 2 + 2 <= n and arr[i * 2 + 2] != -1:
continue
if minV > arr[i]:
minV = arr[i]
minIdx = i
path = []
path.insert(0, str(minV))
while minIdx != 0:
f = (minIdx - 1) // 2
path.insert(0, str(arr[f]))
minIdx = f
return " ".join(path)
# 算法调用
print(getResult(arr))