如何在Java中实现树形数据结构?[关闭]


496

是否有标准的Java库类来表示Java中的树?

具体来说,我需要代表以下内容:

  • 任何节点上的子树可以具有任意数量的子代
  • 每个节点(在根之后)及其子节点将具有字符串值
  • 我需要获取给定节点的所有子节点(某种形式的列表或字符串数​​组)及其字符串值(即,将节点作为输入并返回所有子节点的字符串值作为输出的方法)

是否有任何可用的结构或者我需要创建自己的结构(如果这样的话,实施建议会很棒)。


3
如果您使用的是Java 8,并且想通过流,过滤等遍历您的节点;那么您可能想看看榴莲github.com/diffplug/durian
Ned Twigg

Answers:


306

这里:

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


304
严格来讲,Tree该类不是必需的,因为每个类Node本身都可以看作是一棵树。
约阿希姆·绍尔

34
@Joa,我喜欢具有一个包含根的结构。您可以在树类中添加使调用树而不是单个节点更有意义的方法。
jjnguy 2010年

24
@贾斯汀:例如?这是一个老实的问题:我想不出一种方法对整个树都有意义,而对子树却没有意义。
Joachim Sauer 2010年

22
我同意@Joa的观点,不需要Tree类。我更喜欢通过不添加单独的Tree类并始终使用Node类来在代码中保留树的递归性质。相反,如果需要明确说明您正在处理树的根节点,则将其命名为“树”或“根”。
2012年

89
@Joa我四岁的孩子完全同意您的看法。消除树类。
jjnguy 2014年

122

另一个树结构:

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


2
刚刚发现您的库非常有用。谢谢。但是我想知道如何基于父子之间的引用关系来动态填充树结构。给出的示例是我有一个member1赞助者另一个member2,而member2赞助者成员3等等。已经具有表记录关系,但是不确定我是否可以使用您的库将它们填充到树中。
d4v1dv00 2015年

1
截至2016年,该链接不包含任何源文件或下载
Sharon Ben Asher'1

2
我认为,在上述较高评分的答案之后三年,此答案是比较干净的答案。但是,我将this.children的LinkedList替换为ArrayList。
HopeKing

1
我会为孩子们使用一套。
DPM

我可能是错的,但看来使用此实现,您必须hasNext()在每次调用之前先调用next()以获得有效结果。这不是Iterator规范的一部分。
罗伯·刘易斯·刘易斯

97

实际上,在JDK中实现了一个相当不错的树结构。

看看javax.swing.treeTreeModelTreeNode。它们被设计为可与一起使用,JTreePanel但实际上,它们是一个相当不错的树实现,没有什么可以阻止您在没有swing接口的情况下使用它。

请注意,从Java 9开始,您可能不希望使用这些类,因为它们不会出现在“紧凑配置文件”中


5
是的,我过去曾经使用过它们,它们会从树上做您想要的一切。我唯一想到的缺点是它们各自的实现类的名称的长度:DefaultTreeModel和DefaultMutableTreeNode。详细,但我想并不是那么重要。
Ultimate Gobblement

4
解决该问题的好方法是创建几个静态方法newModel()和newNode(),然后静态导入它们。
加雷斯·戴维斯

140
我会避免在非与Swing相关的功能上使用Swing库。这是不好的编码习惯。您永远不会知道Swing如何实现它们的树,它们的依赖关系以及将来如何改变。Swing不是实用程序库,而是UI库。
jasop

44
我认为不良的编码习惯有些苛刻。
加雷斯·戴维斯

51
javax.swing.tree.TreeModel是一个公共接口(与java.util.List完全一样),并且不会有不兼容的更改。另一个优点是您可以在开发时轻松调试/可视化树。
lbalazscs 2012年

45

那这个呢?

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;
  }
}

5
如何在使用此类对象创建的树上实现DFS?
leba-lev 2012年

3
如何使用此类实现删除叶子?
ghedas'8

2
头场将用作什么?
Acour83年

2
如果该类有一些文档,那就太好了。我不太了解喜欢什么方法setAsParentgetHead做什么方法,这是我真正可以在树数据结构上获得一些帮助的时候。即使是文档的原始来源也没有评论。
灾难


20
public class Tree {
    private List<Tree> leaves = new LinkedList<Tree>();
    private Tree parent = null;
    private String data;

    public Tree(String data, Tree parent) {
        this.data = data;
        this.parent = parent;
    }
}

显然,您可以添加实用程序方法来添加/删除子级。


1
这表明一棵树的父代是一棵树。我相信您正在尝试创建Tree Node类。
Madhur Bhargava

16

您应该首先定义(对于域)树是什么,最好先定义接口。并非所有的树结构都是可修改的,能够添加删除节点应该是可选功能,因此我们为此创建了一个额外的接口。

不需要创建保存值的节点对象,实际上,我认为这是大多数树实现中的主要设计缺陷和开销。如果您查看Swing,TreeModel则不需要节点类(仅DefaultTreeModel使用TreeNode),因为它们并不是真正需要的。

public interface Tree <N extends Serializable> extends Serializable {
    List<N> getRoots ();
    N getParent (N node);
    List<N> getChildren (N node);
}

可变树结构(允许添加和删除节点):

public interface MutableTree <N extends Serializable> extends Tree<N> {
    boolean add (N parent, N node);
    boolean remove (N node, boolean cascade);
}

有了这些接口,使用树的代码就不必太在意树的实现方式了。这使您可以使用通用实现以及专门的实现实现,在这些实现中,您可以通过将函数委派给另一个API来实现树。

示例:文件树结构

public class FileTree implements Tree<File> {

    @Override
    public List<File> getRoots() {
        return Arrays.stream(File.listRoots()).collect(Collectors.toList());
    }

    @Override
    public File getParent(File node) {
        return node.getParentFile();
    }

    @Override
    public List<File> getChildren(File node) {
        if (node.isDirectory()) {
            File[] children = node.listFiles();
            if (children != null) {
                return Arrays.stream(children).collect(Collectors.toList());
            }
        }
        return Collections.emptyList();
    }
}

示例:通用树结构(基于父/子关系):

public class MappedTreeStructure<N extends Serializable> implements MutableTree<N> {

    public static void main(String[] args) {

        MutableTree<String> tree = new MappedTreeStructure<>();
        tree.add("A", "B");
        tree.add("A", "C");
        tree.add("C", "D");
        tree.add("E", "A");
        System.out.println(tree);
    }

    private final Map<N, N> nodeParent = new HashMap<>();
    private final LinkedHashSet<N> nodeList = new LinkedHashSet<>();

    private void checkNotNull(N node, String parameterName) {
        if (node == null)
            throw new IllegalArgumentException(parameterName + " must not be null");
    }

    @Override
    public boolean add(N parent, N node) {
        checkNotNull(parent, "parent");
        checkNotNull(node, "node");

        // check for cycles
        N current = parent;
        do {
            if (node.equals(current)) {
                throw new IllegalArgumentException(" node must not be the same or an ancestor of the parent");
            }
        } while ((current = getParent(current)) != null);

        boolean added = nodeList.add(node);
        nodeList.add(parent);
        nodeParent.put(node, parent);
        return added;
    }

    @Override
    public boolean remove(N node, boolean cascade) {
        checkNotNull(node, "node");

        if (!nodeList.contains(node)) {
            return false;
        }
        if (cascade) {
            for (N child : getChildren(node)) {
                remove(child, true);
            }
        } else {
            for (N child : getChildren(node)) {
                nodeParent.remove(child);
            }
        }
        nodeList.remove(node);
        return true;
    }

    @Override
    public List<N> getRoots() {
        return getChildren(null);
    }

    @Override
    public N getParent(N node) {
        checkNotNull(node, "node");
        return nodeParent.get(node);
    }

    @Override
    public List<N> getChildren(N node) {
        List<N> children = new LinkedList<>();
        for (N n : nodeList) {
            N parent = nodeParent.get(n);
            if (node == null && parent == null) {
                children.add(n);
            } else if (node != null && parent != null && parent.equals(node)) {
                children.add(n);
            }
        }
        return children;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        dumpNodeStructure(builder, null, "- ");
        return builder.toString();
    }

    private void dumpNodeStructure(StringBuilder builder, N node, String prefix) {
        if (node != null) {
            builder.append(prefix);
            builder.append(node.toString());
            builder.append('\n');
            prefix = "  " + prefix;
        }
        for (N child : getChildren(node)) {
            dumpNodeStructure(builder, child, prefix);
        }
    }
}

1
当我执行tree.add(“ A”,“ B”);时,遵循此结构会遇到问题。tree.add(“ A”,“ C”); tree.add(“ C”,“ D”); tree.add(“ E”,“ A”); E是A的父母。我们如何去做?
saNiks

1
嗨,saNicks,上面的代码中有一个错误,导致没有添加最后一个关系。现在它已修复,我还添加了非空检查和(更重要的是):循环检查,可防止违反树结构(向其自身添加代码或作为其子代的祖先之一)。感谢您的提示!
彼得·沃尔瑟

1
我修复了该错误,如果有人在寻找该错误的修复程序,您所要做的就是查看add方法是否返回false,如果它为false,则只需创建一个临时的新LinkedHashSet <N>并将树的节点列表克隆到其中,然后您可以清除在树上,添加在上一步中未添加的父节点,然后将tempNode的全部添加回父树...不过,感谢结构!
saNiks's

2
只需从界面中删除那些无用的公共修饰符即可。
Hamedz '16

1
我如何从中生成一个json数组
Pawan Pandey

12

没有答案提到过分简化但有效的代码,因此这里是:

public class TreeNodeArray<T> {
    public T value;
    public final  java.util.List<TreeNodeArray<T>> kids =  new java.util.ArrayList<TreeNodeArray<T>>();
}


8

如果您要进行白板编码,采访或什至只是打算使用一棵树,这些内容的冗长程度都很大。

还应该说,树之所以不在其中的原因Pair是,您应该使用它将数据封装在类中,并且最简单的实现如下所示:

/***
/* Within the class that's using a binary tree for any reason. You could 
/* generalize with generics IFF the parent class needs different value types.
 */
private class Node {
  public String value;
  public Node[] nodes; // Or an Iterable<Node> nodes;
}

对于任意宽度的树来说确实如此。

如果您想要一个二叉树,通常更容易与命名字段一起使用:

private class Node { // Using package visibility is an option
  String value;
  Node left;
  Node right;
}

或者,如果您想要一个特里:

private class Node {
  String value;
  Map<char, Node> nodes;
}

现在你说你想要

能够获得代表给定节点的输入字符串的所有子代(某种形式的字符串列表或字符串数​​组)

听起来像是您的作业。
但是,由于我有合理的把握,任何截止日期现在都过去了……

import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;

public class kidsOfMatchTheseDays {
 static private class Node {
   String value;
   Node[] nodes;
 }

 // Pre-order; you didn't specify.
 static public List<String> list(Node node, String find) {
   return list(node, find, new ArrayList<String>(), false);
 }

 static private ArrayList<String> list(
     Node node,
     String find,
     ArrayList<String> list,
     boolean add) {
   if (node == null) {
     return list;
   }
   if (node.value.equals(find)) {
     add = true;
   }
   if (add) {
     list.add(node.value);
   }
   if (node.nodes != null) {
     for (Node child: node.nodes) {
       list(child, find, list, add);
     }
   }
   return list;
 }

 public static final void main(String... args) {
   // Usually never have to do setup like this, so excuse the style
   // And it could be cleaner by adding a constructor like:
   //     Node(String val, Node... children) {
   //         value = val;
   //         nodes = children;
   //     }
   Node tree = new Node();
   tree.value = "root";
   Node[] n = {new Node(), new Node()};
   tree.nodes = n;
   tree.nodes[0].value = "leftish";
   tree.nodes[1].value = "rightish-leafy";
   Node[] nn = {new Node()};
   tree.nodes[0].nodes = nn;
   tree.nodes[0].nodes[0].value = "off-leftish-leaf";
   // Enough setup
   System.out.println(Arrays.toString(list(tree, args[0]).toArray()));
 }
}

这使您可以像这样使用:

$ java kidsOfMatchTheseDays leftish
[leftish, off-leftish-leaf]
$ java kidsOfMatchTheseDays root
[root, leftish, off-leftish-leaf, rightish-leafy]
$ java kidsOfMatchTheseDays rightish-leafy
[rightish-leafy]
$ java kidsOfMatchTheseDays a
[]

7

与Gareth的回答相同,请查看DefaultMutableTreeNode。它不是通用的,但似乎符合要求。即使它位于javax.swing包中,它也不依赖于任何AWT或Swing类。实际上,源代码实际上具有注释// ISSUE: this class depends on nothing in AWT -- move to java.util?


大声笑,你怎么还遇到了这堂课?
Pacerier

7

Java中有一些树数据结构,例如JDK Swing中的DefaultMutableTreeNode,斯坦福解析器包中的Tree和其他玩具代码。但是这些都不足以满足一般用途。

Java树项目试图在Java中提供另一个通用树数据结构。这和其他之间的区别是

  • 完全免费。您可以在任何地方使用它(作业除外:P)
  • 小但足够普通。我将所有数据结构都放在一个类文件中,因此很容易复制/粘贴。
  • 不只是玩具。我知道许多Java树代码只能处理二进制树或有限的操作。这个TreeNode远不止于此。它提供了不同的访问节点的方式,例如前序,后序,广度优先,叶,根路径等。此外,还提供了迭代器以实现充分性。
  • 更多的工具将被添加。我愿意添加更多操作以使该项目更全面,特别是如果您通过github发送请求。


5

由于该问题要求一个可用的数据结构,因此可以从列表或数组中构造一棵树:

Object[] tree = new Object[2];
tree[0] = "Hello";
{
  Object[] subtree = new Object[2];
  subtree[0] = "Goodbye";
  subtree[1] = "";
  tree[1] = subtree;
}

instanceof 可用于确定元素是子树还是终端节点。


2
很丑。并且不起作用,如果您的数据对象可能是分别为数组的列表。
user686249

1
我同意这很丑。的Objects就要么是叶对象(例如,StringS)或分支(由阵列表示)。它确实起作用:该代码将被编译,并创建一个小的Strings 树。
奥拉西

5
public abstract class Node {
  List<Node> children;

  public List<Node> getChidren() {
    if (children == null) {
      children = new ArrayList<>();
    }
    return chidren;
  }
}

它变得简单易用。要使用它,请扩展它:

public class MenuItem extends Node {
  String label;
  String href;
  ...
}

3

例如 :

import java.util.ArrayList;
import java.util.List;



/**
 * 
 * @author X2
 *
 * @param <T>
 */
public class HisTree<T> 
{
    private Node<T> root;

    public HisTree(T rootData) 
    {
        root = new Node<T>();
        root.setData(rootData);
        root.setChildren(new ArrayList<Node<T>>());
    }

}

class Node<T> 
{

    private T data;
    private Node<T> parent;
    private List<Node<T>> children;

    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
    public Node<T> getParent() {
        return parent;
    }
    public void setParent(Node<T> parent) {
        this.parent = parent;
    }
    public List<Node<T>> getChildren() {
        return children;
    }
    public void setChildren(List<Node<T>> children) {
        this.children = children;
    }
}

3

过去,我只是为此使用嵌套地图。这就是我今天使用的方法,它非常简单,但是可以满足我的需求。也许这会帮助另一个。

import com.fasterxml.jackson.annotation.JsonValue;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

/**
 * Created by kic on 16.07.15.
 */
public class NestedMap<K, V> {
    private final Map root = new HashMap<>();

    public NestedMap<K, V> put(K key) {
        Object nested = root.get(key);

        if (nested == null || !(nested instanceof NestedMap)) root.put(key, nested = new NestedMap<>());
        return (NestedMap<K, V>) nested;
    }

    public Map.Entry<K,V > put(K key, V value) {
        root.put(key, value);

        return (Map.Entry<K, V>) root.entrySet().stream().filter(e -> ((Map.Entry) e).getKey().equals(key)).findFirst().get();
    }

    public NestedMap<K, V> get(K key) {
        return (NestedMap<K, V>) root.get(key);
    }

    public V getValue(K key) {
        return (V) root.get(key);
    }

    @JsonValue
    public Map getRoot() {
        return root;
    }

    public static void main(String[] args) throws Exception {
        NestedMap<String, Integer> test = new NestedMap<>();
        test.put("a").put("b").put("c", 12);
        Map.Entry<String, Integer> foo = test.put("a").put("b").put("d", 12);
        test.put("b", 14);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(test));

        foo.setValue(99);
        System.out.println(mapper.writeValueAsString(test));

        System.out.println(test.get("a").get("b").getValue("d"));
    }
}

3

我写了一个基于“ HashMap”的小“ TreeMap”类,该类支持添加路径:

import java.util.HashMap;
import java.util.LinkedList;

public class TreeMap<T> extends LinkedHashMap<T, TreeMap<T>> {

    public void put(T[] path) {
        LinkedList<T> list = new LinkedList<>();
        for (T key : path) {
            list.add(key);
        }
        return put(list);
    }

    public void put(LinkedList<T> path) {
        if (path.isEmpty()) {
            return;
        }
        T key = path.removeFirst();
        TreeMap<T> val = get(key);
        if (val == null) {
            val = new TreeMap<>();
            put(key, val);
        }
        val.put(path);
    }

}

它可以用于存储类型为“ T”(通用)的事物树,但(尚)不支持在其节点中存储额外的数据。如果您有这样的文件:

root, child 1
root, child 1, child 1a
root, child 1, child 1b
root, child 2
root, child 3, child 3a

然后,您可以通过执行以下命令使其成为树:

TreeMap<String> root = new TreeMap<>();
Scanner scanner = new Scanner(new File("input.txt"));
while (scanner.hasNextLine()) {
  root.put(scanner.nextLine().split(", "));
}

您会得到一棵漂亮的树。它应该很容易适应您的需求。


2

您可以使用HashTree Jakarta项目中包含的Apache JMeter中包含类。

HashTree类包含在包org.apache.jorphan.collections中。尽管此软件包并未在JMeter项目之外发布,但您可以轻松获得:

1)下载JMeter来源

2)创建一个新包。

3)复制到/ src / jorphan / org / apache / jorphan / collections /中。除Data.java以外的所有文件

4)也复制/src/jorphan/org/apache/jorphan/util/JOrphanUtils.java

5)HashTree可以使用了。


2

Java中没有适合您需求的特定数据结构。您的要求非常具体,因此您需要设计自己的数据结构。查看您的需求,任何人都可以说您需要某种具有某些特定功能的n元树。您可以通过以下方式设计数据结构:

  1. 树的节点的结构将类似于该节点中的内容以及子级列表,例如:class Node {String value; 列出孩子;}
  2. 您需要检索给定字符串的子代,因此可以有2种方法1:节点searchNode(String str),将返回与给定输入具有相同值的节点(使用BFS进行搜索)2:列出getChildren(String str):此方法将在内部调用searchNode以获得具有相同字符串的节点,然后它将创建所有子代字符串值的列表并返回。
  3. 您还需要在树中插入一个字符串。您将必须编写一种方法,例如void insert(String parent,String value):这将再次搜索值等于parent的节点,然后您可以创建具有给定值的Node并将其添加到找到的父级的子级列表中。

我建议您将节点的结构写在一个类中,例如Class Node {String value; 列出子级;}以及所有其他方法,例如在另一个NodeUtils类中进行search,insert和getChildren,以便您还可以传递树的根对特定树执行操作,例如:class NodeUtils {public static Node search(Node root,String value) {//执行BFS并返回Node}


2
    // TestTree.java
// A simple test to see how we can build a tree and populate it
//
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;

public class TestTree extends JFrame {

  JTree tree;
  DefaultTreeModel treeModel;

  public TestTree( ) {
    super("Tree Test Example");
    setSize(400, 300);
    setDefaultCloseOperation(EXIT_ON_CLOSE);
  }

  public void init( ) {
    // Build up a bunch of TreeNodes. We use DefaultMutableTreeNode because the
    // DefaultTreeModel can use it to build a complete tree.
    DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
    DefaultMutableTreeNode subroot = new DefaultMutableTreeNode("SubRoot");
    DefaultMutableTreeNode leaf1 = new DefaultMutableTreeNode("Leaf 1");
    DefaultMutableTreeNode leaf2 = new DefaultMutableTreeNode("Leaf 2");

    // Build our tree model starting at the root node, and then make a JTree out
    // of it.
    treeModel = new DefaultTreeModel(root);
    tree = new JTree(treeModel);

    // Build the tree up from the nodes we created.
    treeModel.insertNodeInto(subroot, root, 0);
    // Or, more succinctly:
    subroot.add(leaf1);
    root.add(leaf2);

    // Display it.
    getContentPane( ).add(tree, BorderLayout.CENTER);
  }

  public static void main(String args[]) {
    TestTree tt = new TestTree( );
    tt.init( );
    tt.setVisible(true);
  }
}

3
请不要只转储代码-解释它的作用,尤其是为什么它比所有其他答案都不同(更好)。
Jan Doggen '16

2

我写了一个树库,可以很好地与Java8配合使用,并且没有其他依赖项。它还对函数式编程中的一些想法提供了宽松的解释,并允许您映射/过滤/修剪/搜索整个树或子树。

https://github.com/RutledgePaulV/prune

该实现对索引没有做任何特别的事情,并且我没有偏离递归,因此,对于大树而言,性能可能会下降,并且可能会破坏堆栈。但是,如果您需要的只是一棵小到中等深度的简单树,那么我认为它已经足够好了。它提供了合理的(基于值的)相等性定义,还具有toString实现,可让您可视化树!


1

请检查下面的代码,其中我使用了Tree数据结构,而没有使用Collection类。该代码可能有错误/改进,但请仅用于参考

package com.datastructure.tree;

public class BinaryTreeWithoutRecursion <T> {

    private TreeNode<T> root;


    public BinaryTreeWithoutRecursion (){
        root = null;
    }


    public void insert(T data){
        root =insert(root, data);

    }

    public TreeNode<T>  insert(TreeNode<T> node, T data ){

        TreeNode<T> newNode = new TreeNode<>();
        newNode.data = data;
        newNode.right = newNode.left = null;

        if(node==null){
            node = newNode;
            return node;
        }
        Queue<TreeNode<T>> queue = new Queue<TreeNode<T>>();
        queue.enque(node);
        while(!queue.isEmpty()){

            TreeNode<T> temp= queue.deque();
            if(temp.left!=null){
                queue.enque(temp.left);
            }else
            {
                temp.left = newNode;

                queue =null;
                return node;
            }
            if(temp.right!=null){
                queue.enque(temp.right);
            }else
            {
                temp.right = newNode;
                queue =null;
                return node;
            }
        }
        queue=null;
        return node; 


    }

    public void inOrderPrint(TreeNode<T> root){
        if(root!=null){

            inOrderPrint(root.left);
            System.out.println(root.data);
            inOrderPrint(root.right);
        }

    }

    public void postOrderPrint(TreeNode<T> root){
        if(root!=null){

            postOrderPrint(root.left);

            postOrderPrint(root.right);
            System.out.println(root.data);
        }

    }

    public void preOrderPrint(){
        preOrderPrint(root);
    }


    public void inOrderPrint(){
        inOrderPrint(root);
    }

    public void postOrderPrint(){
        inOrderPrint(root);
    }


    public void preOrderPrint(TreeNode<T> root){
        if(root!=null){
            System.out.println(root.data);
            preOrderPrint(root.left);
            preOrderPrint(root.right);
        }

    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BinaryTreeWithoutRecursion <Integer> ls=  new BinaryTreeWithoutRecursion <>();
        ls.insert(1);
        ls.insert(2);
        ls.insert(3);
        ls.insert(4);
        ls.insert(5);
        ls.insert(6);
        ls.insert(7);
        //ls.preOrderPrint();
        ls.inOrderPrint();
        //ls.postOrderPrint();

    }

}

2
而不使用Collection类 “啊?那么Queue类来自哪里呢?如上所述,它是一棵二叉树,首先要失败(任何数量的子节点)。
PhiLho 2014年

1

您可以在java.util。*中使用TreeSet类。它的工作方式类似于Binary搜索树,因此已被排序。TreeSet类实现Iterable,Collection和Set接口。您可以像集合一样使用迭代器遍历树。

TreeSet<String> treeSet = new TreeSet<String>();
Iterator<String> it  = treeSet.Iterator();
while(it.hasNext()){
...
}

您可以检查,Java文档和一些其他的


-1

不使用Collection框架的Tree的自定义Tree实现。它包含Tree实现中所需的不同基本操作。

class Node {

    int data;
    Node left;
    Node right;

    public Node(int ddata, Node left, Node right) {
        this.data = ddata;
        this.left = null;
        this.right = null;      
    }

    public void displayNode(Node n) {
        System.out.print(n.data + " "); 
    }

}

class BinaryTree {

    Node root;

    public BinaryTree() {
        this.root = null;
    }

    public void insertLeft(int parent, int leftvalue ) {
        Node n = find(root, parent);
        Node leftchild = new Node(leftvalue, null, null);
        n.left = leftchild;
    }

    public void insertRight(int parent, int rightvalue) {
        Node n = find(root, parent);
        Node rightchild = new Node(rightvalue, null, null);
        n.right = rightchild;
    }

    public void insertRoot(int data) {
        root = new Node(data, null, null);
    }

    public Node getRoot() {
        return root;
    }

    public Node find(Node n, int key) {     
        Node result = null;

        if (n == null)
            return null;

        if (n.data == key)
            return n;

        if (n.left != null)
            result = find(n.left, key);

        if (result == null)
            result = find(n.right, key);

        return result;
    } 

    public int getheight(Node root){
        if (root == null)
            return 0;

        return Math.max(getheight(root.left), getheight(root.right)) + 1; 
    }

    public void printTree(Node n) {     
        if (n == null)
            return;

        printTree(n.left);
        n.displayNode(n);
        printTree(n.right);             
    }

}

11
那是一棵二叉树,它在OP的第一个要求下就失败了
PhiLho 2014年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.