Interview(5)Binary Tree

Interview(5)Binary Tree

Binary Tree

public class BinTreeNode implements BinTreePosition {
protected Object element; // item in this node
protected BinTreePosition parent; //parent
protected BinTreePosition lChild; // left child
protected BinTreePosition rChild; // right child
protected int size; // children size
protected int height; //height
protected int depth; //depth

public BinTreeNode(){
this(null, null, true, null, null);
}

public BinTreeNode(Object e, //element in node
BinTreePosition p, //parent node
boolean asLChild, // left child of parent
BinTreePosition l, // left child
BinTreePosition r // right child
){
size = 1; height = depth = 0; parent = lChid = rChild = null;
element = e;
if(null != p){ //set link to parent
if(asLChild){
p.attachL(this);
}else{
p.attachR(this);
}
}
if(null != l){ attachL(l); }
if(null != r){ attachR(r); }
}

public Object getElem(){ return element; }
public Object setElem(Object obj){
Object bak = element; element = obj; return bak;
}

public boolean hasParent(){
return null != parent;
}

public BinTreePosition getParent(){ return parent; }
public void setParent(BinTreePosition p){ parent = p; }
public boolean isLeaf(){
return !hasLChild() && !hasRChild();
}

public boolean isLChild(){
return (hasParent() && this == getParent().getLChild())? true: false;
}

public boolean hasLChild() { return null != lChild; }
public BinTreePosition getLChild() { return lChild; }
public void setLChild(BinTreePosition c){ lChild = c; }
public boolean isRChild(){
return (hasParent() && this == getParent().getRChild()) ? true : false;
}
public boolean hasRChild() { return null != rChild; }
public BinTreePosition getRChild(){ return rChild; }
public void setRChild(BinTreePosition c){ rChild = c; }
public int getSize() { return size; }
public void udpateSize() {
size = 1; //current node
if(hasLChild()) { size += getLChild().getSize();}
if(hasRChild()) { size += getRChild().getSize(); }
if(hasParent()) { getParent().updateSize(); }
}

public it getHeight(){ return height; }
public void updateHeight() {
height = 0;
if(hasLChild()) { height = Math.max(height, 1 + getLChild().getHeight()); }
if(hasRChild()) { height = Math.max(height, 1 + getRChild().getHeight()); }
if(hasParent()) { getParent().updateHeight(); }
}

public int getDepth(){ return depth; }
public void updateDepth(){
depth = hasParent() ? 1+ getParent().getDepth() : 0; //current node
if(hasLChild()) { getLChild().updateDepth(); }
if(hasRChild()) { getRChild().updateDepth(); }
}

public BinTreePosition getPrev(){ //use mid iterator find the previous node
..snip...
}
…snip...
}

Method: updateSize(v)
Inputs: Binary Tree Node v
Outputs: update the size for v
{
size(v) = 1 + size(lc) + size(rc);
update size for parents till root
}

Method: updateHeight(v) - O(depth(v) + 1)
Input: Binary Tree Node v
Outputs: update height of v
{
height(v) = 0; //no children
if has left child node, height(v) = Max(height(v), 1 + height(lc));
if has right child node, height(v) = Max(height(v), 1 + height(rc));
update height for all parents
}

Method: updateDepth(v)
Inputs: Binary tree Node v
Outputs: Update depth for v
{
if parent node p, depth(v) = depth(p) + 1;
else depth(v) = 0;
if v left child node, updateDepth(lc);
if v right child node, updateDepth(rc);
}

Method: secede(v) - O(depth(v) + size(v) +1)
Inputs: binary tree node v
Outputs: v is root, the sub tree will secede
{
if v has parent,
#1 cut the reference from parent to v
#2 updateSize(v) updateHeight(v)
#3 cut the reference from v to parent
#4 updateDepth(v)
}

Method: attachL(p, c)
Inputs: binary tree node p and c
Outputs: c will be the left child of p
{
if p has left child node, secede(lc)
secede(c)
set the reference between p and c
updateSize(p) updateHeight(p)
updateDepth(c)
}

Inorder Traversal
Method: InorderTraversal(v)
Inputs: binary tree node v
Outputs: v inorder traversal
{
if(null != v){
InorderTraversal(lc) //left child node inorder traversal
visit v
InorderTraversal(rc)//right child node inorder traversal
}
}

Full Binary Tree
public interface FullBinaryTree extend BinaryTree{
public BinTreePosition addLast(Object e);
public Object delLast();
public BinTreePosition posOfNode(int i);
}

…snip...


References:
http://sillycat.iteye.com/blog/2382186