/** * Returns the number of siblings of this node. A node is its own sibling (if it has no parent or * no siblings, this method returns <code>1</code>). * * @return the number of siblings of this node */ public int getSiblingCount() { TreeNode myParent = getParent(); if (myParent == null) { return 1; } else { return myParent.getChildCount(); } }
/** * Returns the root of the tree that contains this node. The root is the ancestor with a null * parent. * * @see #isNodeAncestor * @return the root of the tree that contains this node */ public TreeNode getRoot() { TreeNode ancestor = this; TreeNode previous; do { previous = ancestor; ancestor = ancestor.getParent(); } while (ancestor != null); return previous; }
/** * Returns the number of levels above this node -- the distance from the root to this node. If * this node is the root, returns 0. * * @see #getDepth * @return the number of levels above this node */ public int getLevel() { TreeNode ancestor; int levels = 0; ancestor = this; while ((ancestor = ancestor.getParent()) != null) { levels++; } return levels; }
public TreeNode nextElement() { Enumeration enumer = (Enumeration) queue.firstObject(); TreeNode node = (TreeNode) enumer.nextElement(); Enumeration children = node.children(); if (!enumer.hasMoreElements()) { queue.dequeue(); } if (children.hasMoreElements()) { queue.enqueue(children); } return node; }
public TreeNode nextElement() { Enumeration enumer = stack.peek(); TreeNode node = (TreeNode) enumer.nextElement(); Enumeration children = node.children(); if (!enumer.hasMoreElements()) { stack.pop(); } if (children.hasMoreElements()) { stack.push(children); } return node; }
/** * Returns the nearest common ancestor to this node and <code>aNode</code>. Returns null, if no * such ancestor exists -- if this node and <code>aNode</code> are in different trees or if <code> * aNode</code> is null. A node is considered an ancestor of itself. * * @see #isNodeAncestor * @see #isNodeDescendant * @param aNode node to find common ancestor with * @return nearest ancestor common to this node and <code>aNode</code>, or null if none */ public TreeNode getSharedAncestor(DefaultMutableTreeNode aNode) { if (aNode == this) { return this; } else if (aNode == null) { return null; } int level1, level2, diff; TreeNode node1, node2; level1 = getLevel(); level2 = aNode.getLevel(); if (level2 > level1) { diff = level2 - level1; node1 = aNode; node2 = this; } else { diff = level1 - level2; node1 = this; node2 = aNode; } // Go up the tree until the nodes are at the same level while (diff > 0) { node1 = node1.getParent(); diff--; } // Move up the tree until we find a common ancestor. Since we know // that both nodes are at the same level, we won't cross paths // unknowingly (if there is a common ancestor, both nodes hit it in // the same iteration). do { if (node1 == node2) { return node1; } node1 = node1.getParent(); node2 = node2.getParent(); } while (node1 != null); // only need to check one -- they're at the // same level so if one is null, the other is if (node1 != null || node2 != null) { throw new Error("nodes should be null"); } return null; }
/** * Returns true if <code>anotherNode</code> is an ancestor of this node -- if it is this node, * this node's parent, or an ancestor of this node's parent. (Note that a node is considered an * ancestor of itself.) If <code>anotherNode</code> is null, this method returns false. This * operation is at worst O(h) where h is the distance from the root to this node. * * @see #isNodeDescendant * @see #getSharedAncestor * @param anotherNode node to test as an ancestor of this node * @return true if this node is a descendant of <code>anotherNode</code> */ public boolean isNodeAncestor(TreeNode anotherNode) { if (anotherNode == null) { return false; } TreeNode ancestor = this; do { if (ancestor == anotherNode) { return true; } } while ((ancestor = ancestor.getParent()) != null); return false; }
/** * Returns the total number of leaves that are descendants of this node. If this node is a leaf, * returns <code>1</code>. This method is O(n) where n is the number of descendants of this node. * * @see #isNodeAncestor * @return the number of leaves beneath this node */ public int getLeafCount() { int count = 0; TreeNode node; Enumeration enum_ = breadthFirstEnumeration(); // order matters not while (enum_.hasMoreElements()) { node = (TreeNode) enum_.nextElement(); if (node.isLeaf()) { count++; } } if (count < 1) { throw new Error("tree has zero leaves"); } return count; }
public PathBetweenNodesEnumeration(TreeNode ancestor, TreeNode descendant) { super(); if (ancestor == null || descendant == null) { throw new IllegalArgumentException("argument is null"); } TreeNode current; stack = new Stack<TreeNode>(); stack.push(descendant); current = descendant; while (current != ancestor) { current = current.getParent(); if (current == null && descendant != ancestor) { throw new IllegalArgumentException( "node " + ancestor + " is not an ancestor of " + descendant); } stack.push(current); } }
/** * Returns true if <code>aNode</code> is a child of this node. If <code>aNode</code> is null, this * method returns false. * * @return true if <code>aNode</code> is a child of this node; false if <code>aNode</code> is null */ public boolean isNodeChild(TreeNode aNode) { boolean retval; if (aNode == null) { retval = false; } else { if (getChildCount() == 0) { retval = false; } else { retval = (aNode.getParent() == this); } } return retval; }
/** * Builds the parents of node up to and including the root node, where the original node is the * last element in the returned array. The length of the returned array gives the node's depth in * the tree. * * @param aNode the TreeNode to get the path for * @param depth an int giving the number of steps already taken towards the root (on recursive * calls), used to size the returned array * @return an array of TreeNodes giving the path from the root to the specified node */ protected TreeNode[] getPathToRoot(TreeNode aNode, int depth) { TreeNode[] retNodes; /* Check for null, in case someone passed in a null node, or they passed in an element that isn't rooted at root. */ if (aNode == null) { if (depth == 0) return null; else retNodes = new TreeNode[depth]; } else { depth++; retNodes = getPathToRoot(aNode.getParent(), depth); retNodes[retNodes.length - depth] = aNode; } return retNodes; }
/** * Returns true if <code>anotherNode</code> is a sibling of (has the same parent as) this node. A * node is its own sibling. If <code>anotherNode</code> is null, returns false. * * @param anotherNode node to test as sibling of this node * @return true if <code>anotherNode</code> is a sibling of this node */ public boolean isNodeSibling(TreeNode anotherNode) { boolean retval; if (anotherNode == null) { retval = false; } else if (anotherNode == this) { retval = true; } else { TreeNode myParent = getParent(); retval = (myParent != null && myParent == anotherNode.getParent()); if (retval && !((DefaultMutableTreeNode) getParent()).isNodeChild(anotherNode)) { throw new Error("sibling has different parent"); } } return retval; }
public PostorderEnumeration(TreeNode rootNode) { super(); root = rootNode; children = root.children(); subtree = EMPTY_ENUMERATION; }