Question

如何在不订购的情况下实现树？

Answer 1

最简单的解决方案是让您的数据成为您追加的简单数组。附加到数组时，将数组表示为二叉树时，会为您提供压缩的平衡树。然后通过以下方式计算对该数组的访问：

first_node_of_a_level = (branches^level)-1

然后选择所需级别的子节点。例如，根节点位于（2 ^ 0）-1，即索引0。

The first node on level 1 is (2^1)-1 = 1.
The first node on level 2 is (2^2)-1 = 3.
The first node on level 3 is (2^3)-1 = 7.

这是binary heaps中使用的非常常见的实现。维基百科的文章为您提供了在数组中给定节点索引时找到“child of”或“parent of”的基础知识。

Answer 2

最简单的方法。虽然它应该永远不会发生在现实生活中。 8）

Queue queue = new Queue();

function add(input){
  element = input.popFirst();
  if(element == null) return false;

  node = queue.get();
  node.value = element;
  node.left = new Node();
  queue.put(node.left);
  node.right = new Node();
  queue.put(node.right);
  return true;
}

Node root = new Node();
queue.put(root);
while(add(input)){}
while(!queue.isEmpty){
  destroy queue.get();
}

Answer 3

因此，如果您打算按如下方式分解树：每一层都是2的力量......

Layer0 - root -> 2^0 = 1 (first element) 
Layer1 --------> 2^1 = 2 (next two elements) 
Layer2 --------> 2^2 = 4 (next four elements)

以下列形式分解结构相对微不足道： [4]，[5 | 2]，[7 | 3 | 6 | 8]

你可能想要的是一个关系，其中4个有5个孩子和2个孩子，5个孩子是7岁和3个孩子，2个孩子是6岁和8岁。

所以问题是在迭代这个数组时如何找出给定数字的孩子是什么？假设您已将元素按顺序排列在可索引的数据结构（如数组）中，并且每个元素只有两个子节点或没有子节点，您可以按如下方式创建“树遍历”：

4岁的孩子，在索引0（根），将是索引2 ^ 0和2 ^ 1（索引1和2）索引1和2的子项将是（2 ^ 1 + 1）和（2） ^ 1 + 2）。指数2的儿童将是2 ^ 2 + 1和2 ^ 2 + 2。

因此模式归结为2 ^ i + 1（对于左孩子），2 ^ i + 2（对于右孩子）。我希望这对你的树实现有所帮助。

Answer 4

我只想到一种创建树的方法，就像给出的那样

size( n ) = size of the subtree rooted in n
left( n ) = left child of n
right( n ) = right child of n

然后是插入（x要插入的节点，n是当前[sub]树的根目录）

insert( x, n ) {

 if ( left(n) == null ) {
    left(n) = x;
    return;
 } else if ( right(n) == null ) {
    right(n) = x;
    return;
 } else {
    if ( size( left(n) ) <= size( right(n) ) {
       insert( x, left(n) );
    } else {
       insert( x, right(n) );
    }
 }

基本上一个尝试在树的一侧插入新值，现在它是较小的一个。如果两者的大小相同，那么在左右之前就是偏爱。

我真的不知道，这是否是你要求的，但它至少会根据给定的输入值顺序创建上面的树。

Answer 5

您还可以拥有一个按照您放入普通二叉树

的索引排序的对象

class indexedObject implements Comparable{
    public Int index;
    public int data;

    @Override
    public int compareTo(Object t) {
        if (t instanceof indexedObject) {
            return index.compareTo(((indexedObject)t).index);
        }
    }      
}

然后可以将其插入二叉树

Answer 6

如果你想掌握这类问题，你应该看看HeapSort。

假设您的输入存储在inputArray[] input;中，第一个节点的索引是什么？不是叶子？

input.length / 2 - 1  =>  7 / 2 - 1  =>  2  =>  input[2] is 2

现在，给定数组中任何节点的索引，其子节点的位置是什么？

leftChild = parentIndex * 2 + 1;
rightChild = parentIndex * 2 + 2;
EG: Children of node at index 2 (value 2): left=5 (value 6), right=6(value 8)
NOTE: Watch for ArrayIndexOutOfBound that means that children are missing

设计算法的一种简单方法是创建一个Node数组（带有int值和Node引用的数组），然后将其子项添加到每个非叶节点。您可以考虑更好的算法，这些算法需要更少的额外内存或使用递归作为额外的功课！

插入二叉树（无订单）

6 个答案: