1 / 34

Introduction to Trees: Dynamic Properties, Algorithms, and Data Structures

Learn about the dynamic properties of algorithms and how to build and utilize concrete data structures that are representations of trees.

hivey
Télécharger la présentation

Introduction to Trees: Dynamic Properties, Algorithms, and Data Structures

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. Introduction to treesInstructor: Dimitrios Kosmopoulos 1

  2. Why trees ? • Describe dynamic properties of algorithms • Build and use explicit data structures that are concrete realizations of trees

  3. Definitions A tree is a data structure accessed beginning at a root node Each node is either a leaf or an internal node An internal node has 1 or more children, nodes that can be reached directly from that internal node. The internal node is said to be the parent of its child nodes root node internalnodes leaf nodes 4

  4. Formal Definition of a Tree A tree is either empty (no nodes) or a root connected to 0 or more trees (called sub trees) root sub tree A sub tree B sub tree B 5

  5. Properties of Trees and Nodes siblings: two nodes that have the same parent edge: the link from one node to another path length: the number of edges that must be traversed to get from one node to another root edge siblings path length from root to thisnode is 3 6

  6. More Properties of Trees There is precisely one path connecting any two nodes If the above condition is not satisfied then we have a graph 7

  7. More Properties of Trees depth: the path length from the root of the tree to this node height of a node: The maximum distance (path length) of any leaf from this node a root has a height of 0 the height of a tree is the height of the root of that tree descendants:any nodes that can be reached via 1 or more edges from this node ancestors: any nodes for which this node is a descendant 8

  8. Tree Visualization D B C F E A N O J I K L M G H 9

  9. Tree example: Arithmetic Expression Tree Binary tree associated with an arithmetic expression internal nodes: operators external nodes: operands Example: arithmetic expression tree for the expression (2  (a - 1) + (3  b)) +   2 - 3 b a 1 10

  10. Tree example: Decision Tree Binary tree associated with a decision process internal nodes: questions with yes/no answer external nodes: decisions Example: dining decision Want a fast meal? No Yes How about coffee? On expense account? Yes No Yes No Starbucks Spike’s Al Forno Café Paragon 11

  11. Binary Trees There are many variations on trees A popular one is the binary trees binary tree: a tree with at most two children for each node the possible children are normally referred to as the left and right child parent right child left child 12

  12. Full Binary Tree full binary tree: a binary tree in which each node has exactly 2 or 0 children 13

  13. Perfect Binary Tree perfect binary tree: a binary tree with all leaf nodes at the same depth. All internal nodes have exactly two children. a perfect binary tree has the maximum number of nodes for a given height a perfect binary tree has 2(n+1) - 1 nodes where n is the height of a tree height = 0 -> 1 node height = 1 -> 3 nodes height = 2 -> 7 nodes height = 3 -> 15 nodes 14

  14. Implementation class Node { Item item; Node l; Node r; Node(Item v, Node l, Node r) { this.item = v; this.l = l; this.r = r; } }

  15. Mathematical properties - 1 • A binary tree with N internal nodes has N+1 external nodes • proof : induction Induction • check for N=0 (or N=1), • assume that it holds for N=k, • prove that it holds for N=k+1 (or N)

  16. Mathematical properties - 2 • A binary tree with N internal nodes has 2N links: • N-1 links to internal nodes and • N+1 to external nodes

  17. Mathematical properties - 3 • The height of any binary tree with N-1 internal nodes is at least logN and at most N-1

  18. Binary Tree Traversals Many algorithms require all nodes of a binary tree be visited and the contents of each node processed. There are 4 traditional types of traversals preorder traversal: process the root, then process all sub trees (left to right) in order traversal: process the left sub tree, process the root, process the right sub tree post order traversal: process the left sub tree, process the right sub tree, then process the root level order traversal: starting from the root of a tree, process all nodes at the same depth from left to right, then proceed to the nodes at the next depth. 19

  19. Results of Traversals To determine the results of a traversal on a given tree draw a path around the tree. start on the left side of the root and trace around the tree. The path should stay close to the tree. 12 pre order: process when passdown left side of node12 49 13 5 42 in order: process when passunderneath node13 49 5 12 42 post order: process when passup right side of node13 5 49 42 12 49 42 13 5 20

  20. Pre-order traversal private void traverseR(Node h) { if (h == null) return; h.item.visit(); traverseR(h.l); traverseR(h.r); } void traverse() { traverseR(root); }

  21. In order, post order private void traverseR(Node h) { if (h == null) return; traverseR(h.l); h.item.visit(); traverseR(h.r); } private void traverseR(Node h) { if (h == null) return; traverseR(h.l); traverseR(h.r); h.item.visit(); }

  22. Examples

  23. Stack equivalent –pre order private void traverseS(Node h) { NodeStack s = new NodeStack(max); s.push(h); while (!s.empty()) { h = s.pop(); h.item.visit(); if (h.r != null) s.push(h.r); if (h.l != null) s.push(h.l); } } void traverseS() { traverseS(root); }

  24. Queue instead of stack private void traverseQ(Node h) { NodeQueue q = new NodeQueue(max); q.put(h); while (!q.empty()) { h = q.get(); h.item.visit(); if (h.l != null) q.put(h.l); if (h.r != null) q.put(h.r); } } void traverseQ() { traverseQ(root); }

  25. Level order traversal

  26. Tree parameters computation private static int count(Node h) { if (h == null) return 0; return count(h.l) + count(h.r) + 1; } int count() { return count(root); } private static int height(Node h) { if (h == null) return -1; int u = height(h.l), v = height(h.r); if (u > v) return u+1; else return v+1; } int height() { return height(root); }

  27. Searching in Graphs • Trees are special cases of graphs • In graphs multiple paths between nodes may exist

  28. Depth first • We follow each edge in the graph, with one of two possible outcomes: • if the edge takes us to a node that we have already visited, we ignore it; • if it takes us to a node that we have not yet visited, we follow it there via a recursive call. • The set of all edges that we follow in this way forms a spanning tree for the graph.

  29. Depth first private void dfs(int k) { visit(k); visited[k] = true; for (Node t = adj[k]; t != null; t = t.next) if (!visited[t.v]) dfs(t.v); } A stack can be alternatively used

  30. Depth first 0: 7, 5, 2, 1, 6 7: 1, 2, 0, 4 4: 6, 5, 7 3 3: 5, 4 1: 7,0 2: 7, 0 6: 4, 0 5: 0, 4, 3

  31. Time • Depth first search requires time proportional to V+E, where V is the vertices, E is the nodes, using the adjacency lists representation

  32. Breadth first if we use a queue instead of a stack, then we have breadth-first search, which is analogous to level-order traversal in a tree. void bfs(int k) { intQUEUE q = new intQUEUE(V*V); q.put(k); while (!q.empty()) if (!visited[k = q.get()]) { Node t; visit(k); visited[k] = true; for (t = adj[k]; t != null; t = t.next) if (!visited[t.v]) q.put(t.v); } }

  33. Breadth first 0: 7, 5, 2, 1, 6 7: 1, 2, 0, 4 4: 6, 5, 7 3 3: 5, 4

More Related