1 / 30

CSC401 – Analysis of Algorithms Lecture Notes 4 Trees and Priority Queues

CSC401 – Analysis of Algorithms Lecture Notes 4 Trees and Priority Queues. Objectives: General Trees and ADT Properties of Trees Tree Traversals Binary Trees Priority Queues and ADT. Computers”R”Us. Sales. Manufacturing. R&D. US. International. Laptops. Desktops. Europe. Asia.

fausta
Download Presentation

CSC401 – Analysis of Algorithms Lecture Notes 4 Trees and Priority Queues

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CSC401 – Analysis of AlgorithmsLecture Notes 4 Trees and Priority Queues Objectives: • General Trees and ADT • Properties of Trees • Tree Traversals • Binary Trees • Priority Queues and ADT

  2. Computers”R”Us Sales Manufacturing R&D US International Laptops Desktops Europe Asia Canada The Tree Structure • In computer science, a tree is an abstract model of a hierarchical structure • A tree consists of nodes with a parent-child relation • Applications: • Organization charts • File systems • Programming environments

  3. A C D B E G H F K I J Tree Terminology • Subtree: tree consisting of a node and its descendants • Root: node without parent (A) • Internal node: node with at least one child (A, B, C, F) • External node (a.k.a. leaf ): node without children (E, I, J, K, G, H, D) • Ancestors of a node: parent, grandparent, grand-grandparent, etc. • Depth of a node: number of ancestors • Height of a tree: maximum depth of any node (3) • Descendant of a node: child, grandchild, grand-grandchild, etc. subtree

  4. Tree ADT • Query methods: • boolean isInternal(p) • boolean isExternal(p) • boolean isRoot(p) • Update methods: • swapElements(p, q) • object replaceElement(p, o) • Additional update methods may be defined by data structures implementing the Tree ADT • We use positions to abstract nodes • Generic methods: • integer size() • boolean isEmpty() • objectIterator elements() • positionIterator positions() • Accessor methods: • position root() • position parent(p) • positionIterator children(p)

  5. Depth and Height Algorithmdepth(T,v) if T.isRoot(v) then return 0 else return 1+depth(T, T.parent(v)) • Depth -- the depth of v is the number of ancestors, excluding v itself • the depth of the root is 0 • the depth of v other than the root is one plus the depth of its parent • time efficiency is O(1+d) • Height -- the height of a subtree v is the maximum depth of its external nodes • the height of an external node is 0 • the height of an internal node v is one plus the maximum height of its children • time efficiency is O(n) Algorithmheight(T,v) if T.isExternal(v) then return 0 else h=0; for each wT.children(v) do h=max(h,height(T,w)) return 1+h

  6. 1 Make Money Fast! 2 5 9 1. Motivations 2. Methods References 6 7 8 3 4 2.3 BankRobbery 2.1 StockFraud 2.2 PonziScheme 1.1 Greed 1.2 Avidity Preorder Traversal AlgorithmpreOrder(v) visit(v) foreachchild w of v preorder (w) • A traversal visits the nodes of a tree in a systematic manner • In a preorder traversal, a node is visited before its descendants • The running time is O(n) • Application: print a structured document

  7. 9 cs16/ 8 3 7 todo.txt1K homeworks/ programs/ 4 5 6 1 2 Robot.java20K h1c.doc3K h1nc.doc2K DDR.java10K Stocks.java25K Postorder Traversal AlgorithmpostOrder(v) foreachchild w of v postOrder (w) visit(v) • In a postorder traversal, a node is visited after its descendants • The running time is O(n) • Application: compute space used by files in a directory and its subdirectories

  8. A C B D E F G I H Binary Tree • Applications: • arithmetic expressions • decision processes • searching • A binary tree is a tree with the following properties: • Each internal node has two children • The children of a node are an ordered pair • We call the children of an internal node left child and right child • Alternative recursive definition: a binary tree is either • a tree consisting of a single node, or • a tree whose root has an ordered pair of children, each of which is a binary tree

  9. Want a fast meal? + No Yes   How about coffee? On expense account? 2 - 3 b Yes No Yes No a 1 Starbucks Spike’s Al Forno Café Paragon Binary Tree Examples • Arithmetic expression binary tree • internal nodes: operators • external nodes: operands • Example: arithmetic expression tree for the expression (2(a-1)+(3  b)) • Decision tree • internal nodes: questions with yes/no answer • external nodes: decisions • Example: dining decision

  10. Properties of Binary Trees • Properties: • e = i +1 • n =2e -1 • h  i • h  (n -1)/2 • h+1 e 2h • h log2e • h log2 (n +1)-1 • Notation n number of nodes e number of external nodes i number of internal nodes h height

  11. The BinaryTree ADT extends the Tree ADT, i.e., it inherits all the methods of the Tree ADT Additional methods: position leftChild(p) position rightChild(p) position sibling(p) Update methods may be defined by data structures implementing the BinaryTree ADT BinaryTree ADT

  12. Inorder Traversal AlgorithminOrder(v) ifisInternal (v) inOrder (leftChild (v)) visit(v) ifisInternal (v) inOrder (rightChild (v)) • In an inorder traversal a node is visited after its left subtree and before its right subtree • Time efficiency is O(n) • Application: draw a binary tree • x(v) = inorder rank of v • y(v) = depth of v 6 2 8 1 4 7 9 3 5

  13. +   2 - 3 b a 1 Print Arithmetic Expressions AlgorithmprintExpression(v) ifisInternal (v)print(“(’’) inOrder (leftChild (v)) print(v.element ()) ifisInternal (v) inOrder (rightChild (v)) print (“)’’) • Specialization of an inorder traversal • print operand or operator when visiting node • print “(“ before traversing left subtree • print “)“ after traversing right subtree ((2  (a - 1)) + (3  b))

  14. +   2 - 3 2 5 1 Evaluate Arithmetic Expressions AlgorithmevalExpr(v) ifisExternal (v) returnv.element () else x evalExpr(leftChild (v)) y evalExpr(rightChild (v))  operator stored at v returnx  y • Specialization of a postorder traversal • recursive method returning the value of a subtree • when visiting an internal node, combine the values of the subtrees

  15. Euler Tour Traversal • Generic traversal of a binary tree • Includes a special cases the preorder, postorder and inorder traversals • Walk around the tree and visit each node three times: • on the left (preorder) • from below (inorder) • on the right (postorder) +   L R B 2 - 3 2 5 1

  16. Template Method Pattern public abstract class EulerTour{ protected BinaryTree tree;protected voidvisitExternal(Position p, Result r) { }protected voidvisitLeft(Position p, Result r) { }protected voidvisitBelow(Position p, Result r) { } protected voidvisitRight(Position p, Result r) { }protected Object eulerTour(Position p) { Result r = new Result();if tree.isExternal(p) { visitExternal(p, r); }else {visitLeft(p, r); r.leftResult = eulerTour(tree.leftChild(p));visitBelow(p, r); r.rightResult = eulerTour(tree.rightChild(p)); visitRight(p, r);return r.finalResult; } … • Generic algorithm that can be specialized by redefining certain steps • Implemented by means of an abstract Java class • Visit methods that can be redefined by subclasses • Template method eulerTour • Recursively called on the left and right children • A Result object with fields leftResult, rightResult and finalResult keeps track of the output of the recursive calls to eulerTour

  17. Specializations of EulerTour public class EvaluateExpressionextends EulerTour{ protected voidvisitExternal(Position p, Result r) {r.finalResult = (Integer) p.element(); } protected voidvisitRight(Position p, Result r) {Operator op = (Operator) p.element();r.finalResult = op.operation( (Integer) r.leftResult, (Integer) r.rightResult ); } … } • We show how to specialize class EulerTour to evaluate an arithmetic expression • Assumptions • External nodes store Integer objects • Internal nodes store Operator objects supporting method operation (Integer, Integer)

  18. B    A D F B A D F   C E C E Data Structure for Trees • A node is represented by an object storing • Element • Parent node • Sequence of children nodes • Node objects implement the Position ADT

  19. D C A B E  B A D     C E Data Structure for Binary Trees • A node is represented by an object storing • Element • Parent node • Left child node • Right child node • Node objects implement the Position ADT 

  20. Vector-Based Binary Tree • Level numbering of nodes of T: p(v) • if v is the root of T, p(v)=1 • if v is the left child of u, p(v)=2p(u) • if v is the right child of u, p(v)=2p(u)+1 • Vector S storing the nodes of T by putting the root at the second position and following the above level numbering • Properties: Let n be the number of nodes of T, N be the size of the vector S, and PM be the maximum value of p(v) over all the nodes of T • N=PM+1 • N=2^((n+1)/2)

  21. Tree interface BinaryTree interface extending Tree Classes implementing Tree and BinaryTree and providing Constructors Update methods Print methods Examples of updates for binary trees expandExternal(v) removeAboveExternal(w) v expandExternal(v) v A A   removeAboveExternal(w) A B B C w Java Implementation

  22. JDSL is the Library of Data Structures in Java Tree interfaces in JDSL InspectableBinaryTree InspectableTree BinaryTree Tree Inspectable versions of the interfaces do not have update methods Tree classes in JDSL NodeBinaryTree NodeTree JDSL was developed at Brown’s Center for Geometric Computing See the JDSL documentation and tutorials at http://jdsl.org InspectableTree Tree InspectableBinaryTree BinaryTree Trees in JDSL

  23. A priority queue stores a collection of items An item is a pair(key, element) Main methods of the Priority Queue ADT insertItem(k, o) -- inserts an item with key k and element o removeMin() -- removes the item with smallest key and returns its element Additional methods minKey(k, o) -- returns, but does not remove, the smallest key of an item minElement() -- returns, but does not remove, the element of an item with smallest key size(), isEmpty() Applications: Standby flyers Auctions Stock market Priority Queue ADT

  24. Keys in a priority queue can be arbitrary objects on which an order is defined Two distinct items in a priority queue can have the same key Mathematical concept of total order relation  Reflexive property:x  x Antisymmetric property:x  yy  x  x = y Transitive property:x  yy  z  x  z Total Order Relation

  25. A comparator encapsulates the action of comparing two objects according to a given total order relation A generic priority queue uses an auxiliary comparator The comparator is external to the keys being compared When the priority queue needs to compare two keys, it uses its comparator Methods of the Comparator ADT, all with Boolean return type isLessThan(x, y) isLessThanOrEqualTo(x,y) isEqualTo(x,y) isGreaterThan(x, y) isGreaterThanOrEqualTo(x,y) isComparable(x) Comparator ADT

  26. Sorting with a Priority Queue AlgorithmPQ-Sort(S, C) • Inputsequence S, comparator C for the elements of S • Outputsequence S sorted in increasing order according to C P priority queue with comparator C whileS.isEmpty () e S.remove (S.first ()) P.insertItem(e, e) whileP.isEmpty() e P.removeMin() S.insertLast(e) • We can use a priority queue to sort a set of comparable elements • Insert the elements one by one with a series of insertItem(e, e) operations • Remove the elements in sorted order with a series of removeMin() operations • The running time of this sorting method depends on the priority queue implementation

  27. Implementation with an unsorted sequence Store the items of the priority queue in a list-based sequence, in arbitrary order Performance: insertItem takes O(1) time since we can insert the item at the beginning or end of the sequence removeMin, minKey and minElement take O(n) time since we have to traverse the entire sequence to find the smallest key Implementation with a sorted sequence Store the items of the priority queue in a sequence, sorted by key Performance: insertItem takes O(n) time since we have to find the place where to insert the item removeMin, minKey and minElement take O(1) time since the smallest key is at the beginning of the sequence Sequence-based Priority Queue

  28. Selection-Sort • Selection-sort is the variation of PQ-sort where the priority queue is implemented with an unsorted sequence • Running time of Selection-sort: • Inserting the elements into the priority queue with ninsertItem operations takes O(n) time • Removing the elements in sorted order from the priority queue with nremoveMin operations takes time proportional to1 + 2 + …+ n • Selection-sort runs in O(n2) time

  29. Insertion-Sort • Insertion-sort is the variation of PQ-sort where the priority queue is implemented with a sorted sequence • Running time of Insertion-sort: • Inserting the elements into the priority queue with ninsertItem operations takes time proportional to1 + 2 + …+ n • Removing the elements in sorted order from the priority queue with a series of nremoveMin operations takes O(n) time • Insertion-sort runs in O(n2) time

  30. Instead of using an external data structure, we can implement selection-sort and insertion-sort in-place A portion of the input sequence itself serves as the priority queue For in-place insertion-sort We keep sorted the initial portion of the sequence We can use swapElements instead of modifying the sequence 5 4 2 3 1 5 4 2 3 1 4 5 2 3 1 2 4 5 3 1 2 3 4 5 1 1 2 3 4 5 1 2 3 4 5 In-place Insertion-sort

More Related