Question

二叉树。校长是可以理解的，但它们在数组或关联数组方面看起来是什么样的呢？

如果我可以使用的数据结构是：

AssociativeArray={tag:value,tag:value,tag:value} 

(of course, each tag is unique)

和

Array=[value,value,value] 
(where the value can be any data type including array)

的示例：

DictOfWords={greeting:"hello",sound:"music",sleep:"dream",words:["hello","music","dream"]}
listOfWords=["hello","music","dream",DictOfWords]

从一个或两个构建的二叉树看起来会是什么样的？

此外，用于单词搜索的trie的数据结构看起来像是从那些数据结构构建的？

trie的节点会是什么样的？它会是一个关联数组还是一个线性数组或两者的某种组合？我理解from this post“每个角色都有一个节点”

顶级结构也是如此：

线索= {A：{}，B {}，C {} ...}

或

线索= {A：[]，B：[]，C：{} ...}

或

线索= [ “一”， “B”， “C” ...]

Answer 1

二叉树：

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

可以表示为：

[1, 2, 3, 4, 5, 6, 7]

因此，索引i的子节点位于索引2i和2i+1。

或者它可以表示为：

{1:[2,3], 2:[4,5], 3:[6,7]}

在某处引用root。

<强> Trie树

可以表示为：

{1:{a:2, b:3},
 2:{a:4, b:5},
 3:{},
 4:{},
 5:{}
}

Answer 2

Tries和Binary Trees通常不被认为是数组或关联数组。它们被认为是节点的集合，通常作为结构实现。例如，二叉树看起来像

struct BTreeNode
{
    value_type value;
    BTreeNode* left;
    BTreeNode* right;
};

尝试往往看起来像

struct TrieNode
{
    char_type  letter;
    associative_array<char_type, TrieNode*> children;
};

现在，如果你只是想用数组和关联数组对它进行建模，那么问题将是：你打算用它们做什么？如果您只需要将数据存储在树/特里结构中，那么您有很多选择。但是，如果您确实想要将BTree用作BTree或Trie作为Trie，我们必须确保您使用任何转换将结构转换为数组/关联数组。最简单的一个：将每个结构视为具有恒定条目数的关联数组

通常会以

完成

BTreeNode oneNode(1, null, null);
BTreeNode threeNode(3, null, null);
BTreeNode twoNode(2, oneNode, threeNode);
BTreeNode sixNode(6, null, null);
BTreeNode fiveNode(5, null, sixNode);
BTreeNode fourNode(4, twoNode, fiveNode);

您可以将这些结构转换为关联数组，然后获取

fourNode = {   value: 4,
               left: {
                   value: 2,
                   left: {
                       value: 1
                   },
                   right: {
                       value: 3
                   }
               },
               right: {
                   value: 5,
                   right: {
                       value:6
                   }
              }
          }

有一个类似的转换到数组，但读取

不太明显

存储“abc”“abd”“abe”“ace”的可比较的trie创建一个看起来像

的trie结构

    a
   / \
  b    c
/ | \   \

c d e e

从结构到上面的值进行相同的转换，你得到

trie =  {
            letter: 'a',
            children: {
                'b': {
                    letter: 'b'
                    children: {
                        'c': { letter: 'c' },
                        'd': { letter: 'd' },
                        'e': { letter: 'e' }
                    }
                'c': {
                    letter: 'c'
                    children: {
                        'e': { letter: 'e' }
                    }
            }
       }

然而，坚持我的原始评论，“它们在数组或关联数组方面看起来真的如何？”是无法回答的。它们实际上并没有实现为数组或关联数组，所以“真的看起来像”不能与“数组或关联数组”一起使用。根据它们真正构造的节点结构来考虑它们，你会更进一步。

例如，有一种自平衡二叉树的想法。如果您将结构视为一组链接在一起的节点，那么这些结构很容易理解。如果你试着用数组/关联数组来思考自平衡二叉树，你就会遇到很多麻烦，因为它们往往会有一个指向父节点的指针，这会产生一些看起来混乱的关联数组。

struct SelfBalancingBTreeNode
{
    value_type value;
    SelfBalancingBTreeNode* parent;
    SelfBalancingBTreeNode* left;
    SelfBalancingBTreeNode* right;
};

要对此建模，您需要有非常有趣的关联数组结构

leftNode = { value: 1, parent: null, left: null, right: null}
parentNode = value: 2, parent: null, left: leftNode, right: null}
leftNode['parent'] = parentNode

创建使用关联数组时通常不会想到的循环

实现二叉树 - 数据结构，trie

2 个答案: