How to implement a tree data-structure in Java?

Существует ли какой-либо стандартный класс библиотеки Java для представления дерева в Java?

В частности, мне нужно представить следующее:

• Поддерево в любом узле может иметь произвольное количество дочерних элементов


• Каждый узел (после корневого) и его дочерние элементы будут иметь строковое значение


• Мне нужно получить все дочерние элементы (своего рода список или массив строк) данного узла и его строковое значение (т. Е. Метод, который будет принимать узел в качестве входных данных и возвращать все строковые значения дочернего узла в качестве выходных данных)

Есть ли какая-либо доступная структура для этого или мне нужно создать свою собственную (если да, то предложения по реализации были бы замечательными).

Здесь:

public class Tree<T> {
    private Node<T> root;

    public Tree(T rootData) {
        root = new Node<T>();
        root.data = rootData;
        root.children = new ArrayList<Node<T>>();
    }

    public static class Node<T> {
        private T data;
        private Node<T> parent;
        private List<Node<T>> children;
    }
}

Это базовая древовидная структура, которую можно использовать для String или любого другого объекта. Довольно легко реализовать простые деревья, чтобы делать то, что вам нужно.

Все, что вам нужно добавить, это методы для добавления в, удаления из, обхода и конструкторы. Node Это базовый строительный блок Tree.

Еще одна древовидная структура:

public class TreeNode<T> implements Iterable<TreeNode<T>> {

    T data;
    TreeNode<T> parent;
    List<TreeNode<T>> children;

    public TreeNode(T data) {
        this.data = data;
        this.children = new LinkedList<TreeNode<T>>();
    }

    public TreeNode<T> addChild(T child) {
        TreeNode<T> childNode = new TreeNode<T>(child);
        childNode.parent = this;
        this.children.add(childNode);
        return childNode;
    }

    // other features ...

}

Пример использования:

TreeNode<String> root = new TreeNode<String>("root");
{
    TreeNode<String> node0 = root.addChild("node0");
    TreeNode<String> node1 = root.addChild("node1");
    TreeNode<String> node2 = root.addChild("node2");
    {
        TreeNode<String> node20 = node2.addChild(null);
        TreeNode<String> node21 = node2.addChild("node21");
        {
            TreeNode<String> node210 = node20.addChild("node210");
        }
    }
}

БОНУС
Увидеть полноценное дерево с:

• итератор


• поиск


• Java / C#

https://github.com/gt4dev/yet-another-tree-structure

На самом деле в JDK реализована довольно хорошая древовидная структура.

Взгляните на javax.swing.tree, TreeModel и TreeNode. Они предназначены для использования с JTreePanel но на самом деле это довольно хорошая древовидная реализация, и ничто не мешает вам использовать ее без интерфейса swing.

Обратите внимание, что начиная с Java 9, вы можете не использовать эти классы, поскольку они не будут присутствовать в "Компактных профилях".

Что насчет этого?

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;

/**
  * @author ycoppel@google.com (Yohann Coppel)
  * 
  * @param <T>
  *          Object's type in the tree.
*/
public class Tree<T> {

  private T head;

  private ArrayList<Tree<T>> leafs = new ArrayList<Tree<T>>();

  private Tree<T> parent = null;

  private HashMap<T, Tree<T>> locate = new HashMap<T, Tree<T>>();

  public Tree(T head) {
    this.head = head;
    locate.put(head, this);
  }

  public void addLeaf(T root, T leaf) {
    if (locate.containsKey(root)) {
      locate.get(root).addLeaf(leaf);
    } else {
      addLeaf(root).addLeaf(leaf);
    }
  }

  public Tree<T> addLeaf(T leaf) {
    Tree<T> t = new Tree<T>(leaf);
    leafs.add(t);
    t.parent = this;
    t.locate = this.locate;
    locate.put(leaf, t);
    return t;
  }

  public Tree<T> setAsParent(T parentRoot) {
    Tree<T> t = new Tree<T>(parentRoot);
    t.leafs.add(this);
    this.parent = t;
    t.locate = this.locate;
    t.locate.put(head, this);
    t.locate.put(parentRoot, t);
    return t;
  }

  public T getHead() {
    return head;
  }

  public Tree<T> getTree(T element) {
    return locate.get(element);
  }

  public Tree<T> getParent() {
    return parent;
  }

  public Collection<T> getSuccessors(T root) {
    Collection<T> successors = new ArrayList<T>();
    Tree<T> tree = getTree(root);
    if (null != tree) {
      for (Tree<T> leaf : tree.leafs) {
        successors.add(leaf.head);
      }
    }
    return successors;
  }

  public Collection<Tree<T>> getSubTrees() {
    return leafs;
  }

  public static <T> Collection<T> getSuccessors(T of, Collection<Tree<T>> in) {
    for (Tree<T> tree : in) {
      if (tree.locate.containsKey(of)) {
        return tree.getSuccessors(of);
      }
    }
    return new ArrayList<T>();
  }

  @Override
  public String toString() {
    return printTree(0);
  }

  private static final int indent = 2;

  private String printTree(int increment) {
    String s = "";
    String inc = "";
    for (int i = 0; i < increment; ++i) {
      inc = inc + " ";
    }
    s = inc + head;
    for (Tree<T> child : leafs) {
      s += "\n" + child.printTree(increment + indent);
    }
    return s;
  }
}