KezvhLib/src-lib/net/kezvh/collections/trees/Tree.java

   1 /**
   2  *
   3  */
   4 package net.kezvh.collections.trees;
   5
   6 import java.util.Collection;
   7 import java.util.List;
   8
   9 /**
  10  * @author afflux
  11  *
  12  * @param <E> collection element type
  13  */
  14 public interface Tree<E> {
  15         /**
  16          * @return a value associated with the root node of this tree
  17          */
  18         E value();
  19
  20         /**
  21          * @param value new value
  22          * @return the previous value of the root node
  23          */
  24         E setValue(E value);
  25
  26         /**
  27          * you can't add things to this list, though things may be removed
  28          *
  29          * @return a list of children of the tree, backed by the tree
  30          */
  31         List<Tree<E>> children();
  32
  33         /**
  34          * backed by the tree
  35          *
  36          * @param index index of the child
  37          * @return child at the index
  38          */
  39         Tree<E> child(int index);
  40
  41         /**
  42          * @param e a value to associate with a new child of the tree
  43          * @return the new child node
  44          */
  45         Tree<E> addChild(E e);
  46
  47         /**
  48          * @param index index in the list of children to insert the child
  49          * @param e a value to associate with a new child of the tree
  50          * @return the new child node
  51          */
  52         Tree<E> addChild(int index, E e);
  53
  54         /**
  55          * remove a child node from the tree
  56          *
  57          * @param index index of a child
  58          * @return tree that exists with that child as the root
  59          */
  60         Tree<E> pruneChild(int index);
  61
  62         /**
  63          * like "Collection.addAll", the original tree will not become *part* of this tree
  64          * merely, its elements and structure will become part of this tree.
  65          *
  66          * @param tree
  67          * @return the child tree node of the tree as spliced
  68          */
  69         Tree<E> splice(Tree<E> tree);
  70
  71         /**
  72          * @param index index at which to insert the spliced tree
  73          * @param tree
  74          * @return the child tree node of the tree as spliced
  75          */
  76         Tree<E> spliceAt(int index, Tree<E> tree);
  77
  78         /**
  79          * @param index in the list of children
  80          * @return the value of the child at the specified index
  81          */
  82         E childValue(int index);
  83
  84         /**
  85          * @return true if the node has no children
  86          */
  87         boolean isLeaf();
  88
  89         /**
  90          * @return a collection of elements of the tree backed by the tree. iterates inorder.
  91          */
  92         Collection<E> inorder();
  93
  94         /**
  95          * @return a collection of elements of the tree backed by the tree. iterates preorder (depth first).
  96          */
  97         Collection<E> preorder();
  98
  99         /**
 100          * @return a collection of elements of the tree backed by the tree. iterates postorder.
 101          */
 102         Collection<E> postorder();
 103
 104         /**
 105          * @return a collection of elements of the tree backed by the tree. iterates level order (breadth first).
 106          */
 107         Collection<E> levelOrder();
 108
 109         /**
 110          * @return number of nodes in the tree
 111          */
 112         int size();
 113
 114         /**
 115          * @return the tree to which this is a child, if such exists
 116          */
 117         Tree<E> parent();
 118 }