interface Position<E> { E getelement() throws IllegalStateExcept..; }

Transcription

1 1 interface Position<E> { E getelement() throws IllegalStateExcept..; } position node e

2 Tree ADT: Interface 2 Elements of Tree ADT stores elements at Positions which, in fact, Tree ADT are abstractions of Nodes as in Lists, each position / node is defined relative to its neighbouring positions parent and children NOTE: Terms position and node may be used interchangeably. Generic Methods of Tree ADT (unrelated to a specific tree structure) Collect all elements in a linear container (list or array); returns an iterator over that container. Running times: O(n). public int size(); /* return the number of nodes in the tree */ public boolean isempty(); /* return true if the tree is empty true only initially */ public Iterable<Position<E>> positions(); /* returns an iterable collection of the nodes. */ public Iterator<E> iterator(); /* return an iterator of all the elements stored in the tree */ public E replace(position<e> p, E e) throws ; /* replaces the element stored at a given node */

3 Tree ADT: Interface (cont.) 3

4 Tree ADT: Interface (cont.) 4 Example [ iterable vs. iterator ]

5 5 public Iterable<Position<E>> positions() { } PositionList<Position<E>> positions = new NodePositionList<Position<E>>(); if(size!= 0) preorderpositions(root(), positions); return positions; public Iterator<E> iterator() { // assign positions in preorder Iterable<Position<E>> positions = positions(); PositionList<E> elements = new NodePositionList<E>(); for (Position<E> pos: positions) // enhanced for loop elements.addlast(pos.element()); return elements.iterator(); // an iterator of elements }

6 Tree ADT: Interface (cont.) 6 Accessor Methods (allow user to navigate through the tree) public Position<E> root() throws ; /* return the position of the root of the tree or null if empty */ public Position<E> parent(position<e> p) throws /* return the position of a parent of a node */ public Iterable<Position<E>> children(position<e> p) throws ; /* return an iterable collection of all the children of a node */ public int numchildren(position<e> p) throws ; /* returns the number of children of position p */ Query Methods (make programming with trees easier ) public boolean isinternal(position<e> v) throws ; /* test whether a node is internal */ public boolean isexternal(position<e> v) throws ; /* test whether a node is external */ public boolean isroot(position v) throws ; /* test whether a node is the root of the tree */

7 Tree ADT: Interface (cont.) 7

8 Link Structure for Trees 8 Linked Implementation most natural way to implement Tree ADT, of Tree ADT as it allows non-linear arrangement of nodes Node in Tree ADT object containing 1) (reference to the) element stored in this node 2) reference/link to the parent 3) reference/link to children container children container can be either a list or an array of nodes parent Why not a separate reference to each individual child? Simplified implementation of children() method. childrencontainer element

9 Link Structure for Trees (cont.) 9 Example [ tree and its linked list implementation ] A A B C D E B C D E

10 Link Structure for Trees (cont.) 10 TNode Class generalization of Position ADT implements Position interface } public class TNode<E> implements Position { private E element; private TNode<E> parent; private List<E> children; public TNode(E e, TNode<E> p, List<E> c) { setelement(e); setparent(p); setchildren(c); } public E geteement() { return element; } public void setelement(e e) { element = e; } public TNode<E> getparent() { return parent; } public void setparent(tnode<e> p) { parent = p; } public List<E> getchildren() { return children; } public void setchildren(list<e> c) { children = c; } parent children element accessor & update methods

11 public E replace(position<e> v, E e) { E temp = ((TNode<E>) v).element(); ((TNode) v).setelement(e); return temp; } Link Structure for Trees (cont.) 11 LinkedTree Class public class LinkedTree implements Tree { protected Position<E> root; /* equivalent to head in linked lists*/ protected int size; public LinkedTree() { root = null; /* start with an empty tree */ size = 0; }... /* methods for adding/removing nodes */ public boolean isinternal(position<e> v) { return (((Tnode<E>) v).getchildren()!=null); } public Position<E> parent(position<e> v) { return ((Tnode<E>) v).getparent(); }

12 Link Structure for Trees (cont.) 12 public Iterable<Position<E>> positions() { LinkedList<Positions<E>> positions = new LinkedList<Position<E>>(); if (size!=0) inorderpositions(root(), positions); return positions; } public Iterator<E> iterator() { Iterable<Position<E>> positions = positions(); LinkedList<E> elements = new LinkedList<E>(); for (Position<E> pos: positions) elements.addlast(pos.element()); return elements.iterator(); } } Traverses the tree in-order starting from the root. Each node is visited once and stored in positions list! We will see more of it later. For-each loop (Java 5 feature) helps in iterating over java collections, i.e. classes of Iterable type.

13 Link Structure for Trees (cont.) 13 Example [ for-each loop ] For-each loop for (type var : arr) { body-of-loop } for (type var : coll) { body-of-loop } Equivalent for loop for (int i = 0; i < arr.length; i++) { type var = arr[i]; body-of-loop } for (Iterator<T> iter = coll.iterator(); iter.hasnext(); ) { type var = iter.next(); body-of-loop }

14 Link Structure for Trees (cont.) 14 Link Structure for Trees - Performance space complexity - Good! only O(n), since there is one TNode object per every element of the tree all methods, except positions(), iterator(), run in O(1) time Method size, isempty positions, iterator replace root, parent children(v) isinternal, isexternal, isroot Time O(1) O(n) O(1) O(1) O(n) O(1) The above methods can be used to solve some interesting problems on trees: e.g. find the depth of a node, tree height, or path between two nodes.

15 Basic Algorithms on Trees: Depth 15 Node Depth the depth of a node corresponds to the number of its ancestors (excluding itself) A depth(a) = depth(root) = 0 depth(e) = 2 B C D E F G H Algorithm for Finding Node Depth - Recursive Implementation public int depth(tree<e> T, Position<E> v) { if (T.isRoot(v)) return 0; } else return (1 + depth(t, T.parent(v)));

16 Basic Algorithms on Trees: Depth (cont.) 16 Running Time of public int depth(tree<e> T, Position<E> v) Θ(1+d v ), where d v denotes the depth of node v NOTE: isroot(v), parent(v) run in O(1) time Worst Case RT of public int depth(tree<e> T, Position<E> v) in a tree of size n O(n), where n is the total number of nodes in T A A depth(e) = d v B C D B E F G H C D

17 Basic Algorithms on Trees: Height 17 height(a) = 4 A B C D E F G I J K height(b) = 3 height(f) = 2 height(j) = 1 height(k) = 0 Depth: count nodes above! number of hops from the root to this node Height: count nodes below! number of hops from this node to its most distant child (descendant) Node Height if node is external, then its height is 0; otherwise its height = 1 + max height of its children Tree Height corresponds to the height of its root or max depth of its external nodes Tree Height = Root Height = Depth of Most Distant External Node

18 Basic Algorithms on Trees: Height (cont.) 18 Algorithm for Finding Tree Height: Iterative Implementation Visit each node if external, calculate its depth and compared it to the maximum depth seen so far. public int height1(tree<e> T) { O(n) } int h=0; for (Position<E> v : T.positions()) { if (T.isExternal(v)) h = Math.max(h, depth(t,v)); }; }; return h; auxiliary variable keeps max depth found so far i O(n) O(d v ) for each external node run depth(t,v) O(d v ) i i e e e i e

19 Basic Algorithms on Trees: Height (cont.) 19 A B C D find height(j) and compare it to heights of other external nodes visited up to this point E F G I J Running Time of public int height1(tree T) O( 2n + d v ), where E - set of all external nodes v E But, what is 1) the max # of external nodes, and 2) max node-depth on the given tree??? Worst Case Running Time of public int height1(tree T) O( 2n + n 2 ) = O( n 2 ), since E =(n-1) in the worst case and d v =(n-1) in the worst case

20 Basic Algorithms on Trees: Height (cont.) 20 Algorithm for Finding Tree Height: Recursive Implementation! Height of a node = 1 + max height of its children. public int height2(tree<e> T, Position<E> v) { } if (T.isExternal(v)) return 0; else { O(c k ) int h=0; for (Position<E> w: T.children(v)) return 1+h; }; O(c k ) h = Math.max(h, height2(t, w)); Calls height2 on this child and compare the child s height with the max height found so far. Computes height of subtree T rooted at v; should initially be called on the root. e i e i e i i e

21 Basic Algorithms on Trees: Height (cont.) 21 height(a) = 1 + max height of A s children height(b) = 1 + max height of B s children A if node external return h=0; otherwise, obtain children s h and return max(h)+1 B C D E F G I J Running Time of public int height2(tree T, Position v) O( c k + c k + 1) = O( 2 c k + 1) = O( 2n + 1) = O(n), k k k where k denotes different levels of the tree, c k denotes the number of children at level k