Question

我目前正致力于将整数数组转换为具有给定顺序的树（可以是2,3,4,5，...）。到目前为止，我只是设法让它为2阶树的树工作，我正在努力为更高的订单实现代码。

它是如何工作的，我们得到一组数字（例如1 2 3 4 5 6 7 8 2），最后一个表示树的顺序。在这种情况下，2，导致这棵树：

然后我们必须从提供的数字中预先打印和下订单打印生成的树。因此，对于pre-order打印，我得到1 2 4 8 5 3 6 7，而对于post-order打印，我得到8 4 5 2 6 7 3 1，这两者都是正确答案。

我用于构建树的代码是：

public static Node arrayToTree(String[] input, int order) {
    Node root = createNode(input, 1, order);
    return root;
}

public static Node createNode(String[] input, int i, int order) {
    if(i <= input.length) {
        String val = input[i-1];
        if(val != null){
            Node t = new Node(val);
            for(int j = 0; j < order; j++) {
                t.children[j] = createNode(input, order * i + j, order);
            }
            return t;
        }
    }
    return null;
}

class Node {
    public Node[] children = new Node[64];
    public String val;

    public Node(String val) {
         this.val = val;
    }
}

实际的问题是如何在createNode函数中获取正确的索引，以便Node t的子节点实际上是正确的。因此，例如，如果输入是1 2 3 4 3 ..意味着树的顺序是3，因此根是1并且具有子2,3和4.其在索引1,2和3上。

public static void main(String[]args) {
    String[] input = new String[]{"1", "2", "3", "4", "5", "6", "7", "8"};
    int order = 2;
    Node tree = arrayToTree(input, order);
    System.out.print("Preorder: ");
    preorder(tree);
    System.out.println();
    System.out.print("Postorder: ");
    postorder(tree);
}

public static void preorder(Node node) {
    System.out.print(node.val + " ");
    for(Node n : node.children) {
        if(n != null) preorder(n);
    }
}

public static void postorder(Node node) {
    for(Node n : node.children) {
        if(n != null) postorder(n);
    }
    System.out.print(node.val + " ");
}

这是主要功能，包括后期订单和预订单打印，让您了解以后如何在主程序中使用它。

Answer 1

我假设您必须使用递归来执行此操作，这会使其复杂化;否则会有更简单的解决方案。

首先在视觉上解决这个问题可能最容易。以下是数组中节点的索引的映射（不是它们的值）。使用索引而不是值的一般原因是值是无意义的，它们是符号的，而索引是计算中有用的数学量。

2
---
0 -> 1 2
1 -> 3 4
2 -> 5 6
3 -> 7

3
---
0 -> 1 2 3
1 -> 4 5 6
2 -> 7

4
---
0 -> 1 2 3 4
1 -> 5 6 7

注意模式：i的每个父项的第一个孩子的索引是i * order + 1。由于我们正在使用索引，这些索引恰好比其中的值小1，因此将i s移动1：

public static Node arrayToTree(String[] input, int order) {
    Node root = createNode(input, 0, order); // 0 instead of 1
    return root;
}

public static Node createNode(String[] input, int i, int order) {
    if(i < input.length) {  // < instead of <=
        String val = input[i]; // i instead of i-1
        if(val != null){
            Node t = new Node(val);
            for(int j = 0; j < order; j++) {
                t.children[j] = createNode(input, ???, order);
            }
            return t;
        }
    }
    return null;
}

并使用上面找到的模式完成递归公式。以下是我为input[16]和订单2,3和4获得的结果（请原谅用作视觉辅助的未格式化的树）：

2
---
1
2 3 | 
4 5 | 6 7 | 
8 9 | 10 11 | 12 13 | 14 15 | 
16 

Preorder: 1 2 4 8 16 9 5 10 11 3 6 12 13 7 14 15 
Postorder: 16 8 9 4 10 11 5 2 12 13 6 14 15 7 3 1  

3
---
1
2 3 4 | 
5 6 7 | 8 9 10 | 11 12 13 | 
14 15 16 | 

Preorder: 1 2 5 14 15 16 6 7 3 8 9 10 4 11 12 13 
Postorder: 14 15 16 5 6 7 2 8 9 10 3 11 12 13 4 1 

4
---
1
2 3 4 5 | 
6 7 8 9 | 10 11 12 13 | 14 15 16 

Preorder: 1 2 6 7 8 9 3 10 11 12 13 4 14 15 16 5 
Postorder: 6 7 8 9 2 10 11 12 13 3 14 15 16 4 5 1

将整数数组转换为具有给定顺序的树

1 个答案: