Question

如何设计具有大量（无限数量）分支的树？

我们应该使用哪种数据结构来存储子节点？

Answer 1

你实际上无法存储无数的孩子，因为这不适合记忆。但是，您可以存储无限制地许多子项 - 也就是说，您可以创建树，其中每个节点可以包含任意数量的子节点，没有固定的上限。

有几种标准方法可以做到这一点。您可以让每个树节点存储其所有子节点的列表（可能作为动态数组或链接列表），这通常通过尝试来完成。例如，在C ++中，您可能会遇到以下情况：

struct Node {
   /* ... Data for the node goes here ... */
   std::vector<Node*> children;
};

或者，您可以使用left-child/right-sibling representation，它将多路树表示为二叉树。这通常用于优先级队列，如二项式堆。例如：

struct Node {
    /* ... data for the node ... */
    Node* firstChild;
    Node* nextSibling;
};

希望这有帮助！

Answer 2

是的！您可以创建一个按需实现子项的结构（即“懒孩子”）。在这种情况下，孩子的数量很容易在功能上无限。

Haskell非常适合创建“功能无限”的数据结构，但由于我不知道Haskell的内容，所以这里是一个Python示例：

class InfiniteTreeNode:
    ''' abstract base class for a tree node that has effectively infinite children '''
    def __init__(self, data):
        self.data = data
    def getChild(self, n):
        raise NotImplementedError

class PrimeSumNode(InfiniteTreeNode):
    def getChild(self, n):
        prime = getNthPrime(n) # hypothetical function to get the nth prime number
        return PrimeSumNode(self.data + prime)

prime_root = PrimeSumNode(0)
print prime_root.getChild(3).getChild(4).data # would print 18: the 4th prime is 7 and the 5th prime is 11

现在，如果你要搜索PrimeSumNode深度为2，你可以找到两个素数之和的所有数字（如果你能证明它包含所有偶数整数， you can win a big mathematical prize!）。

Answer 3

我建议您使用带有左子节点和右子节点以及父节点的Node类。

   public class Node
   {      
      Node<T>  parent;      
      Node<T>  leftChild;  
      Node<T>  rightChild;  
      T          value;       


      Node(T val)
      {
         value = val;
         leftChild = new Node<T>();
         leftChild.parent = this;
         rightChild = new Node<T>();
         rightChild.parent = this;
      }

你可以像这样设置爷爷，叔叔和兄弟姐妹。

  Node<T> grandParent()
  {
     if(this.parent.parent != null)
     {
         return this.parent.parent;
     }
     else
         return null;
  }


  Node<T> uncle()
  {
      if(this.grandParent() != null)
      {
          if(this.parent == this.grandParent().rightChild)
          {
              return this.grandParent().leftChild;
          }
          else
          {
              return this.grandParent().rightChild;
          }
      }
      else
          return null;

  }

  Node<T> sibling()
  {
      if(this.parent != null)
      {
          if(this == this.parent.rightChild)
          {
              return this.parent.leftChild;
          }
          else
          {
              return this.parent.rightChild;
          }
      }
      else
          return null;
  }

并且不可能有无限的孩子，至少你有无限的记忆。

祝你好运！

希望这会对你有所帮助。

Answer 4

类似这样的东西

Node {
  public String name;
  Node n[]; 
}

像这样添加节点

public Node[] add_subnode(Node n[]) {
    for (int i=0; i<n.length; i++) {
        n[i] = new Node();
        p("\n Enter name: ");
        n[i].name = sc.next();

        p("\n How many children for "+n[i].name+"?");
        int children = sc.nextInt();

        if (children > 0) {
            Node x[] = new Node[children];
            n[i].n = add_subnode(x);
        }
    }
    return n;
}

完整的工作代码：

class People {
  private Scanner sc;
  public People(Scanner sc) {
    this.sc = sc;
  }
public void main_thing() {
    Node head = new Node();
    head.name = "Head";
    p("\n How many nodes do you want to add to Head: ");
    int nodes = sc.nextInt();

    head.n = new Node[nodes];
    Node[] n = add_subnode(head.n);

    print_nodes(head.n);

}

public Node[] add_subnode(Node n[]) {
    for (int i=0; i<n.length; i++) {
        n[i] = new Node();
        p("\n Enter name: ");
        n[i].name = sc.next();

        p("\n How many children for "+n[i].name+"?");
        int children = sc.nextInt();

        if (children > 0) {
            Node x[] = new Node[children];
            n[i].n = add_subnode(x);
        }
    }
    return n;
}

public void print_nodes(Node n[]) {
    if (n!=null && n.length > 0) {
    for (int i=0; i<n.length; i++) {
        p("\n "+n[i].name);
        print_nodes(n[i].n);
    }
    }
}

public static void p(String msg) {
    System.out.print(msg);
}
}

class Node {
    public String name;
    Node n[]; 
}

是否有可能设计一个节点有无限多个孩子的树？

4 个答案: