Download
cse 326 data structures trees n.
Skip this Video
Loading SlideShow in 5 Seconds..
CSE 326: Data Structures Trees PowerPoint Presentation
Download Presentation
CSE 326: Data Structures Trees

CSE 326: Data Structures Trees

240 Vues Download Presentation
Télécharger la présentation

CSE 326: Data Structures Trees

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. CSE 326: Data Structures Trees Lecture 6: Friday, Jan 17, 2003

  2. Trees Material: Weiss Chapter 4 • N-ary trees • Binary Search Trees • AVL Trees • Splay Trees

  3. Tree Jargon • Nodes: A, B, …, F • Root node: A • Leaf nodes: B, E, F, D • Edges: (A,B), (A,C), …, (C, F) • Path: sequence of nodes connected by edges. • Path examples: (B), (A,B),(A,C), (A,C,E), (A,C,F), (C), etc A C D B F E Questions. A tree has N nodes.How many edges does it have ? How many paths ?

  4. Tree Jargon • Length of a path = number of edges • Depth of a node x = length of path from root to x • Height of node x = length of longest path from x to a leaf • Depth and height of tree = height of root • The label of a node: A, B, C, … depth=0, height = 2 A C D B F depth = 2, height=0 E

  5. Definition and Tree Trivia Graph-theoretic definition of a Tree: A tree is a graph for which there exists a node, called root, such that: -- for any node x, there exists exactly one path from the root to x Recursive Definition of a Tree: A tree is either: a. empty, or b. it has a node called the root, followed by zero or more trees called subtrees

  6. Implementation of Trees • Obvious Pointer-Based Implementation: Node with value and pointers to children • Problem? A C D B F E

  7. 1st Child/Next Sibling Representation • Each node has 2 pointers: one to its first child and one to next sibling A A C D B C D B F E F E

  8. Nested List Representation • Each node has a pointer to a list containing its children A A C D B C D B F E F E

  9. Application: Arithmetic Expression Trees Example Arithmetic Expression: A + (B * (C / D) ) Tree for the above expression: + A * • Used in most compilers • No parenthesis need – use tree structure • Can speed up calculations e.g. replace • / node with C/D if C and D are known • Calculate by traversing tree (how?) B / D C

  10. Traversing Trees + • Preorder: Root, then Children • + A * B / C D • Postorder: Children, then Root • A B C D / * + • Inorder: Left child, Root, Right child • A + B * C / D A * B / D C

  11. Example Code for Recursive Preorder void print_preorder ( TreeNode T) { if ( T == NULL ) return; print_element(T.Element()); print_preorder(T.FirstChild()); print_preorder(T.NextSibling()); } What is the running time for a tree with N nodes?

  12. Binary Trees • Properties • max # of leaves = 2depth(tree) • max # of nodes = 2depth(tree)+1 – 1 • We care a lot about the depth: • max depth = n-1 • min depth = log(n) (why ?) • average depth for n nodes = (over all possible binary trees) • Representation: A B C D E F G H I J

  13. Binary Trees Notice: • we distinguish between left child and right child A A B C B C  F F G H G H

  14. Search tree property all keys in left subtree smaller than root’s key all keys in right subtree larger than root’s key result: easy to find any given key inserts/deletes by changing links Binary Search Tree 8 5 11 2 6 10 12 4 7 9 14 13

  15. Searching in a Binary Search Tree Boolean find(int x, TreeNode T) { if ( T == NULL ) return false; if (x == T.Element) return true; if (x < T.Element) return find(x, T.Left); return find(x, T.Right); } 10 5 15 2 9 20 7 17 30 What is the running time ?

  16. Insert a Key TreeNode insert(int x, TreeNode T) { if ( T == NULL ) return new TreeNode(x,null,null); if (x == T.Element) return T; if (x < T.Element) T.Left = insert(x, T.Left); else T.Right = insert(x, T.Right); return T; } 10 5 15 2 9 20 What is the running time ? 3 7 17 30

  17. Delete a Key How do you delete: 17 ? 9 ? 20 ????? 10 5 15 2 9 20 7 17 30

  18. TreeNode min(Node T) { if (T.Left == NULL) return T; else return min(T.Left); } FindMin 10 5 15 2 9 20 17 7 30 How many children can the min of a node have?

  19. Successor Find the next larger node in this node’s subtree. • When it exists, it is the next largest node in entire tree 10 5 15 TreeNode succ(TreeNode T) { if (T.right == NULL) return NULL; else return min(T.right); } 2 9 20 17 7 30 How many children can the successor of a node have?

  20. Deletion - Leaf Case Delete(17) 10 5 15 2 9 20 17 7 30

  21. Deletion - One Child Case Delete(15) 10 5 15 2 9 20 7 30

  22. Deletion - Two Children Case Delete(5) 10 5 20 2 9 30 7 replace node with value guaranteed to be between the left and right subtrees: the successor

  23. Deletion - Two Children Case Delete(5) 10 5 20 2 9 30 7 always easy to delete the successor – always has either 0 or 1 children!

  24. Deletion - Two Child Case Delete(5) 10 7 20 2 9 30 7 Finally copy data value from deleted successor into original node What is the cost of a delete operation ? Can we use the predecessor instead of successor ?

  25. Cost of the Operations • find, insert, delete : • Need to compute height(T) • For a tree T with n nodes: • height(T)  n • height(T)  log(n) (why ?) time = O(height(T))

  26. Height of the Binary Search Tree • Height depends critically on the order in which we insert the data: • E.g. 1,2,3,4,5,6,7 or 7,6,5,4,3,2,1, or 4,2,6,1,3,5,7 1 7 4 2 6 3 2 6 5 4 4 1 3 5 7 5 3 6 2 7 1 Which insertion order corresponds to what tree ? Which tree do we prefer and why ?

  27. The Average Depth of a BST • Insert the elements 1 <2 < ... < nin some order, starting with the empty tree • For each permutation, : • T = the BST after inserting (1), (2) , ... , (n) • The Average Depth: • Let’s compute it !

  28. The Average Depth of a BST • H(n) seems hard, let’s compute something else instead • The internal path length of a tree T is: depth(T) = sum of all depths of all nodes in T • Clearly depth(T)/n  height (T) (why ?) • The average internal path length is:

  29. The Average Depth of a BST • Compute D(n) now:

  30. The Average Depth of a BST • Compute D(n) now: n D(n) = 2i=1,n-1D(i) + n(n – 1) (n-1) D(n-1) = 2i=1,n-2D(i) + (n – 1)(n – 2) n D(n) – (n – 1) D(n-1) = 2D(n-1) +2(n – 1) n D(n) = (n+1)D(n-1) + 2(n – 1) D(n)/n+1 = D(n-1)/n + 2(n-1)/n(n+1) < D(n-1)/n + 2/n D(n)/n+1 < 2( 1/n + 1/(n-1) + ... + 1/3 + 1/2 + 1)  2log(n) D(n) = (n log n) H(n) = (log n)

  31. The Average Depth of a BST • What have we achieved ? • The average depth of a BST is: H(n) = (log n)

  32. Random Input vs. Random Trees Trees Inputs 1,2,3 3,2,1 1,3,2 3,1,2 2,1,3 2,3,1 For three items, the shallowest tree is twice as likely as any other – effect grows as n increases. For n=4, probability of getting a shallow tree > 50%

  33. Average cost • The average, amortized cost of n insert/find operations is O(log(n)) • But the average, amortized cost of n insert/find/delete operations can be as bad as sqrt(n) • Deletions make life harder (recall stretchy arrays) • Read the book for details • Need guaranteed cost O(log n) – next time