Binary Trees (and Big O notation)

Transcription

1 Binary Trees (and Big O notation) Professor Hugh C. Lauer CS-2303, System Programming Concepts (Slides include materials from The C Programming Language, 2 nd edition, by Kernighan and Ritchie, Absolute C++, by Walter Savitch, The C++ Programming Language, Special Edition, by Bjarne Stroustrup, and from C: How to Program, 5 th and 6 th editions, by Deitel and Deitel) 1

2 Definitions Linked List Tree A data structure in which each element is dynamically allocated and in which elements point to each other to define a linear relationship Singly- or doubly-linked Stack, queue, circular list A data structure in which each element is dynamically allocated and in which each element has more than one potential successor Defines a partial order CS-2303, A-Term 2012 Binary Trees 2

3 Binary Tree A linked list but with two links per item struct treeitem { type ; treeitem *, *; }; 3

4 Binary Tree (continued) Binary tree needs a root struct treeitem { type ; treeitem *, *; }; struct treeitem *root; Binary trees often drawn with root at top! Unlike ordinary trees in the forest More like the root systems of a tree 4

5 Definitions (continued) See K & R, 6.5 Binary Tree Subtree A tree in which each element has two potential successors The set of nodes that are successors to a specific node, either directly or indirectly Root of a tree The node of the tree that is not the successor to any other node, all other nodes are (directly or indirectly) successors to it CS-2303, A-Term 2012 Binary Trees 5

6 Binary Tree A linked list but with two links per item struct treeitem { type ; treeitem *, *; }; 6

7 Purpose of a Tree (Potentially) a very large data structure Capable of storing very many items In an orderly way Need to find items by value I.e., need to search through the data structure to see if it contains an item with the value we want Need to add new items If value is not already in the tree, add a new item so that it can be easily found in future Why not use a linked list? 7

8 Searching and Adding to a Binary Tree A linked list but with two links per item struct treeitem { type ; Look recursively down sequence treeitem of *, branches *; until }; either Desired node is found; or Null branch is encountered Replace with pointer to new item Decide which branch to follow based on 8

9 Example Searching a Tree typedef struct _treeitem { char *word; int count; _treeitem *, *; } treeitem; // part of // part of treeitem *finditem(treeitem *p, char *w) { if (p == NULL) return NULL; // item not found } int c = strcmp(w, p->word); if (c == 0) return p; else if (c < 0) return finditem(p->, w); else return finditem(p->, w); 9

10 Example Adding an Item treeitem *additem(treeitem *p, char *w) { if (p == NULL){ p = malloc(sizeof(treeitem)); char *c = malloc(strlen(w)+1); p->word = strcpy(c, w); p->count = 1; p-> = p-> = NULL; return p; }; int c = strcmp(w, p->word); if (c == 0) p->count++; else if (c < 0) p-> = additem(p->, w); else p-> = additem(p->, w); return p; } Why do this? 10

11 Binary Tree Question: how many calls to additem for a tree with 10 6 nodes? Assume balanced I.e., approx same number of nodes on each subtree 11

12 Answer Approximately 20 calls to additem Note: 2 10 = Therefore Therefore it takes approximately 20 two-way branches to cover 10 6 items! How many comparisons would it take to search a linked list of 10 6 items? 12

13 Observation Problems like this occur in real life all the time Need to maintain a lot of data Usually random Need to search through it quickly Need to add (or delete) items dynamically Need to sort on the fly I.e., as you are adding and/or deleting items 13

14 Questions? 14

15 Binary Trees (continued) Binary tree does not need to be balanced i.e., with approximate same # of nodes hanging from or However, it often helps with performance Multiply-branched trees Like binary trees, but with more than two links per node 15

16 Binary Trees (continued) Binary tree does not need to be balanced i.e., with approximate same # of nodes hanging from or However, it helps with performance Time to reach a leaf node is O(log 2 n), where n is number of nodes in tree Multiply-branched trees Like binary trees, but with more than two links per node 16

17 Order of Traversing Binary Trees In-order Traverse sub-tree (in-order) Visit node itself Traverse sub-tree (in-order) Pre-order Visit node first Traverse sub-tree Traverse sub-tree Post-order Traverse sub-tree Traverse sub-tree Visit node last 17

18 Question Suppose we wish to print out the strings stored in the tree of the previous example in alphabetical order? What traversal order of the tree should we use? 18

19 Another Example of Binary Tree x = (a.real*b.imag - b.real*a.imag) / sqrt(a.real*b.real a.imag*b.imag) = x / - * *.. sqrt.. - a real b imag b real a imag 19

20 Question What kind of traversal order is required for the expression on the previous slide? In-order? Pre-order? Post-order? 20

21 Binary Trees in Compilers Used to represent the structure of the compiled program Optimizations Common sub-expression detection Code simplification Loop unrolling Parallelization Reductions in strength e.g., substituting additions for multiplications, etc. Many others 21

22 Questions? 22

23 Big O notation New Topic 23

24 Linked Lists Again Linear data structure Easy to grow and shrink Easy to add and delete items Time to search for an item O(n) 24

25 Binary Trees Again Non-linear data structure Easy to grow and shrink Easy to add and delete items Time to search for an item O(log n) 25

26 Definition: Big-O Of the order of A characterization of the number of operations in an algorithm in terms of a mathematical function of the number of data items involved O(n) means that the number of operations to complete the algorithm is proportional to n E.g., searching a list with n items requires, on average, n/2 comparisons with s 26

27 Big-O (continued) O(n): proportional to n i.e., linear O(n 2 ): proportional to n 2 i.e., quadratic O(k n ) proportional to k n i.e., exponential O(log n) proportional to log n i.e., sublinear O(n log n) Worse than O(n), better than O(n 2 ) O(1) independent of n; i.e., constant 27

28 Questions on Big-O? 29