华为OD机试算法：数组二叉树

题目描述

二叉树也可以用数组来存储，给定一个数组，树的根节点的值存储在下标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))