1

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

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

    1
   / \
  2   3
 / \ / \
 4 5 6 7
/
8

然后，我们必须根据提供的数字对生成的构建树进行预排序和排序后打印。因此，对于我得到的预购印刷品1 2 4 8 5 3 6 7和我得到的后购印刷品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 函数中获取正确的索引，以便节点 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 + " ");
}

这是 postorder 和 preorder 打印的主要功能，让您了解稍后在主程序中应该如何工作。

4

1 回答 1

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，因此将is 移动 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
于 2017-12-01T00:50:09.477 回答