it-swarm.dev

Datová struktura Java stromu?

Existuje dobrá dostupná (standardní Java) datová struktura, která představuje strom v Javě?

Konkrétně potřebuji reprezentovat následující:

  • Strom v libovolném uzlu může mít libovolný počet dětí
  • Každý uzel (za kořenem) je jen řetězec (jehož děti jsou také řetězce)
  • Musím být schopen dostat všechny děti (nějaký druh seznamu nebo pole řetězců) s ohledem na vstupní řetězec reprezentující daný uzel

Existuje pro to nějaká dostupná struktura nebo musím vytvořit vlastní (pokud by návrhy na implementaci byly skvělé).

469
ikl

Tady:

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

Jedná se o základní stromovou strukturu, kterou lze použít pro String nebo jakýkoliv jiný objekt. Je poměrně snadné realizovat jednoduché stromy, abyste dělali to, co potřebujete.

Vše, co potřebujete přidat, jsou metody přidání, odebrání, procházení a konstruktory. Node je základní stavební prvek Tree.

286
jjnguy

Ještě další stromová struktura:

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 ...

}

Použití vzorku:

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

BONUS
Viz úplný strom s:

  • iterátor
  • vyhledávání
  • Java/C #

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

112
Grzegorz Dev

Ve skutečnosti je v JDK implementována velmi dobrá stromová struktura.

Podívejte se na javax.swing.tree , TreeModel , a TreeNode . Jsou navrženy pro použití s ​​JTreePanel, ale ve skutečnosti jsou to docela dobrý strom implementace a není nic, co vám brání v používání s mimo rozhraní swing.

Všimněte si, že jako u jazyka Java 9 můžete tyto třídy nepoužívat, protože nebudou přítomny v 'Kompaktní profily' .

97
Gareth Davis

Co tohle?

import Java.util.ArrayList;
import Java.util.Collection;
import Java.util.HashMap;

/**
  * @author [email protected] (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;
  }
}
44
MountainX

I napsal malou knihovnu, která zpracovává generické stromy. Je to mnohem lehčí než houpačka. Mám také projekt maven pro to.

23
Vivin Paliath
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;
    }
}

Samozřejmě můžete přidat nástroje pro přidávání/odebírání dětí.

17
PaulJWilliams

Měli byste začít definováním toho, co je strom (pro doménu), což je nejlepší provést definováním interface first. Ne všechny struktury stromů lze modifikovat, protože jsou schopny add a remove nodes by měly být volitelnou funkcí, takže pro to uděláme další rozhraní.

Není třeba vytvářet uzlové objekty, které drží hodnoty , ve skutečnosti to vidím jako hlavní konstrukční chybu a režii ve většině implementací stromů. Když se podíváte na Swing, TreeModel je bez tříd uzlů (pouze DefaultTreeModel používá TreeNode), protože nejsou opravdu potřeba.

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

Struktura proměnného stromu (umožňuje přidávat a odebírat uzly):

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

Vzhledem k těmto rozhraním nemusí kód, který používá stromy, dbát na to, jak je strom implementován. To vám umožní použít generické implementace stejně jako specializované ones, kde si strom realizujete delegováním funkcí na jiné API.

Příklad: struktura stromu stromů

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

Příklad: obecná stromová struktura (na základě vztahu rodič/dítě):

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);
        }
    }
}
15
Peter Walser

Žádná odpověď nezmiňuje příliš zjednodušený, ale pracovní kód, takže zde je:

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

Můžete použít libovolné XML API Java jako Document a Node ..as XML je stromová struktura s řetězci

10

Existuje několik stromových datových struktur v Javě, jako je DefaultMutableTreeNode v JDK Swing, Tree v Stanford Parser balíčku a další kódy hraček. Ale žádný z nich není dostačující, ale dostatečně malý pro všeobecné účely.

Java-tree project se pokouší poskytnout další stromovou strukturu stromů v Javě. Rozdíl mezi tímto a ostatními je

  • Úplně zdarma. Můžete ji použít kdekoli (kromě domácího úkolu: P)
  • Malé, ale dost obecné. Vložil jsem všechno datové struktury do jednoho souboru třídy, takže by bylo snadné kopírovat/vkládat.
  • Nejen hračky. Jsem si vědoma desítek kódů stromu Java, které mohou zpracovávat pouze binární stromy nebo omezené operace. Tento TreeNode je mnohem více. Poskytuje různé způsoby navštěvování uzlů, jako je preorder, postorder, breadthfirst, listy, cesta ke kořenům, atd. Navíc jsou pro dostatečnost k dispozici iterátory.
  • Budou přidány další nástroje. Jsem ochoten přidat další operace, aby byl tento projekt komplexní, zejména pokud pošlete žádost prostřednictvím githubu.
7
Yifan Peng

Stejně jako Garethova odpověď, podívejte se na DefaultMutableTreeNode . Není to obecný, ale jinak se zdá, že zapadá do zákona. Ačkoli je to v balíčku javax.swing, nezávisí na žádné třídě AWT nebo Swing. Zdrojový kód má ve skutečnosti komentář // ISSUE: this class depends on nothing in AWT -- move to Java.util?

7
Mark

Pokud děláte tabule kódování, rozhovor, nebo dokonce jen plánujete použít strom, výřečnost z nich je o něco víc.

Dále by mělo být řečeno, že důvod, proč strom není tam jako, řekněme, Pair (o kterém by se dalo říci), je proto, že byste měli zapouzdřit svá data ve třídě, která je používá, a / nejjednodušší implementace vypadá takto:

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

To je opravdu pro libovolný šířkový strom.

Pokud jste chtěli binární strom, je často jednodušší ho používat s pojmenovanými poli:

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

Nebo pokud chcete trie:

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

Teď jsi řekl, že chceš

být schopný dostat všechny děti (nějaký druh seznamu nebo pole řetězců) daný vstupní řetězec reprezentovat daný uzel

To zní jako vaše domácí úkoly.
Ale protože jsem si jistý, že již uplynula nějaká lhůta…

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

Tímto způsobem získáte:

$ 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
[]
6
dlamblin
public abstract class Node {
  List<Node> children;

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

Tak jednoduché, jak se dostává a velmi snadné použití. Chcete-li ji použít, rozbalte ji:

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

Vzhledem k tomu, že otázka se ptá na dostupnou datovou strukturu, může být strom vytvořen ze seznamů nebo polí:

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

instanceof lze použít k určení, zda prvek je podstrom nebo terminálový uzel.

5
Olathe

Napsal jsem malou třídu "TreeMap" založenou na "HashMap", která podporuje přidávání cest:

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

}

To může být použito k uložení stromu věcí typu "T" (generické), ale (zatím) nepodporuje ukládání dalších dat v jeho uzlech. Máte-li takový soubor:

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

Potom můžete provést strom provedením:

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

A dostanete pěkný strom. Mělo by být snadné přizpůsobit se vašim potřebám.

3
mevdschee

Například :

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
JAN

V minulosti jsem na to použil vnořenou mapu. To je to, co používám dnes, je to velmi jednoduché, ale vyhovuje mým potřebám. Možná to pomůže další.

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"));
    }
}
2
KIC
    // 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);
  }
}
2
Tony Narloch

Můžete použít třídu HashTree zahrnutou v Apache JMeter, která je součástí projektu Jakarta.

Třída HashTree je obsažena v balíčku org.Apache.jorphan.collections. Ačkoli tento balíček není vydán mimo projekt JMeter, můžete jej snadno získat:

1) Stáhněte si zdroje JMeter .

2) Vytvořte nový balíček.

3) Kopírovat na něm/src/jorphan/org/Apache/jorphan/collections /. Všechny soubory kromě Data.Java

4) Kopírovat také /src/jorphan/org/Apache/jorphan/util/JOrphanUtils.Java

5) HashTree je připraven k použití.

2
David

V jazyce Java neexistuje žádná specifická datová struktura, která by vyhovovala vašim požadavkům. Vaše požadavky jsou poměrně specifické a pro to je třeba navrhnout vlastní datovou strukturu. Při pohledu na vaše požadavky může každý říct, že potřebujete nějaký n-ary strom s některými specifickými funkcemi. Strukturu dat můžete navrhnout následujícím způsobem:

  1. Struktura uzlu stromu by byla jako obsah v uzlu a seznam dětí jako: class Node {String value; Seznam dětí;}
  2. Musíte získat děti daného řetězce, takže můžete mít 2 metody 1: Node searchNode (String str), vrátí uzel, který má stejnou hodnotu jako daný vstup (použijte BFS pro vyhledávání) 2: List getChildren (String str): tato metoda interně zavolá searchNode, aby uzel měl stejný řetězec a pak vytvořil seznam všech řetězcových hodnot dětí a návratu.
  3. Budete také muset vložit řetězec do stromu. Budete muset napsat jednu metodu say void insert (String parent, String hodnota): toto bude opět hledat uzel s hodnotou rovnou rodiči a pak můžete vytvořit uzel s danou hodnotou a přidat do seznamu dětí do nalezeného rodiče. .

Navrhuji, abyste zapsali strukturu uzlu do jedné třídy, jako je Class Node {String value; Seznam dětí;} a všechny ostatní metody, jako je vyhledávání, vkládání a getChildren v jiné třídě NodeUtils, takže můžete také předat kořen stromu, abyste provedli operaci na konkrétním stromě jako: class NodeUtils {public static Node search (Node root, hodnota řetězce) {// provést BFS a vrátit uzel}

2
aman rastogi

Napsal jsem stromovou knihovnu, která hraje pěkně s Java8 a nemá žádné další závislosti. Poskytuje také volnou interpretaci některých nápadů z funkčního programování a umožňuje mapovat/filtrovat/procházet/prohledávat celý strom nebo podstromy.

https://github.com/RutledgePaulV/Prune

Implementace nedělá nic zvláštního s indexováním a já jsem neodcházel od rekurze, takže je možné, že s velkými stromy výkon bude degradovat a vy byste mohli vyhodit stack. Ale pokud vše, co potřebujete, je přímočarý strom malé až střední hloubky, myslím, že to funguje dobře. Poskytuje rozumnou (na hodnotách založenou) definici rovnosti a má také implementaci toString, která vám umožní vizualizovat strom!

2
RutledgePaulV

Zkontrolujte prosím níže uvedený kód, kde jsem použil stromové struktury dat, bez použití tříd kolekce. Kód může mít chyby/vylepšení, ale použijte pouze pro informaci

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();

    }

}
1
Amit Mathur

Třídu TreeSet můžete použít v jazyce Java.util. *. Pracuje jako binární vyhledávací strom, takže je již seřazen. Třída TreeSet implementuje rozhraní Iterable, Collection a Set. Stromem s iterátorem můžete procházet jako sadu.

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

Můžete zkontrolovat Java Doc a některé jiné .

1
Oguz