导航基本二叉树答案

【问题标题】：Navigating basic binary tree导航基本二叉树
【发布时间】：2016-10-18 22:42:49
【问题描述】：

所以我需要为我的应用程序创建一个基本的二叉树，但我在概念化如何“导航”时遇到了麻烦，即使在生成过程中也是如此。

每个节点当然有一个地址，并通向另外两个节点，它们分别持有一个正值和负值。我的问题是，如果我想使用循环创建树，我该怎么做？第一次迭代将有两个节点，第三次将有四个，依此类推 - 在推进循环之前如何循环遍历它们的每个地址？

    for(int i=1;i<=5;i++){
        (*currentAddress).value = i;
        (*currentAddress).positive = i;
        (*currentAddress).negative = i*-1;
        //update current address
    }

我是否必须在每次迭代时都使用 BFS 并一直添加节点，直到创建 (2^n-1) 个节点？

【问题讨论】：

看看前序、后序和中序树遍历。这应该为您指明正确的方向。
Binary Tree Insert Algorithm的可能重复
注意：数组索引从 0 到 n-1。所以：for(int i=0;i<5;i++) ...
请学习一下，什么是二叉树（它的结构）。在其他两个节点中没有正值或负值。左子树中的值较小，右子树中的值较大。只有正确理解后，才能开始思考算法。
谢谢大家！是的，Ivan 我的树在这方面有所不同，我已经预先知道所有节点将包含什么（每个“深度级别”中的数字相同，只有一个是正数，另一个是负数。

标签： c

【解决方案1】：

您实际上需要左右指针，对吧？然后你可能想使用递归。例如（用一些随意的语言）：

function Node* MakeNode(value, limit) {
    Node* node = new Node();
    (*node).value = value;
    // don't create any more children once we get to the depth limit.
    if (value < limit) {
        (*node).positive = MakeNode(value + 1);
        (*node).negative = MakeNode(value - 1);
    }
    return node;
}

// create a 5 deep tree
MakeNode(0, 5);

【讨论】：

谢谢！我会尝试申请并充分理解这一点并回复您。

【解决方案2】：

因此，您想使用循环创建指定深度的完整二叉树。这是可能的。但是您应该首先考虑@PaulColdrey 的答案，因为它比较简单。

要迭代地创建二叉树，必须知道它的每个节点都可以用一个位向量唯一标识：

layer 0:                       ___________________[0]___________________ 
                              |                                         |
layer 1:            ________[00]________                       ________[10]________ 
                   |                    |                     |                    |
layer 2:      ___[000]___          ___[100]___           ___[010]___          ___[110]___ 
             |           |        |           |         |           |        |           |
layer 3:  [0000]       [1000]  [0100]       [1100]   [0010]       [1010]  [0110]       [1110]

第 N 层的位表示从第 (N – 1) 层到第 N 层时采用了哪个分支（左：0 / 右：1）。换句话说，位向量是到节点的路径；见上文。

从 0 数到 2^K - 1 就足以得到所有可能的路径到第 K 层节点。最重要的是，在向上计数时，第 N 位永远不会从 0 变为 1，直到所有较低有效位从 0 变为 1——在这种情况下，这意味着当前的第 N 层子树已满。

这允许每层只记住一个当前节点，当父节点更改时重新创建所有子节点。

这是它在 C 中的样子：

struct NODE {
    struct NODE *side[2];
    double data;
};

struct NODE *fulltree(int depth) {
    struct NODE *curr[16] = {};
    int path, layer;

    if ((depth >= 0) && (depth < 16)) { /** reject exceedingly large trees **/
        curr[0] = (struct NODE*)calloc(1, sizeof(struct NODE));
        for (path = 0; path < (1 << depth); ++path)
            for (layer = 1; layer <= depth; ++layer)
                if (((path ^ (path - 1)) >> (depth - layer)) & 1) {
                    curr[layer - 1]->side[(path >> (depth - layer)) & 1] =
                    curr[layer] = (struct NODE*)calloc(1, sizeof(struct NODE));
                    curr[layer]->data =
                    ((path >> (layer - 1)) & 1)? layer : -layer;
                }
    }
    return curr[0];
}

代码假定目标 CPU 上的负整数为 two`s complement。

【讨论】：