1. More on Data Structures in C CS-2301 D-term 20091 More on Data Structures in C CS-2301 System Programming D-term 2009 (Slides include materials from The C Programming Language, 2 nd edition, by Kernighan and Ritchie and from C: How to Program, 5 th and 6 th editions, by Deitel and Deitel)

2. More on Data Structures in C CS-2301 D-term 20092 Linked List Review Linear data structure Easy to grow and shrink Easy to add and delete items Time to search for an item – O(n)

3. More on Data Structures in C CS-2301 D-term 20093 Linked List (continued) payload next payload next payload next payload next struct listItem *head;

4. More on Data Structures in C CS-2301 D-term 20094 Doubly-Linked List (review) prevnext payload prevnext payload prevnext payload prevnext payload struct listItem *head, *tail;

5. More on Data Structures in C CS-2301 D-term 20095 AddAfter(item *p, item *new) Simple linked list {new -> next = p -> next; p -> next = new; } Doubly-linked list {new -> next = p -> next; if (p -> next) p->next->prev = new; new -> prev = p; p -> next = new; }

6. More on Data Structures in C CS-2301 D-term 20096 AddAfter(item *p, item *new) Simple linked list {new -> next = p -> next; p -> next = new; } Doubly-linked list {new -> next = p -> next; if (p -> next) p->next->prev = new; new -> prev = p; p -> next = new; } prevnext payload prevnext payload prevnext payload

7. More on Data Structures in C CS-2301 D-term 20097 AddAfter(item *p, item *new) Simple linked list {new -> next = p -> next; p -> next = new; } Doubly-linked list {new -> next = p -> next; if (p -> next) p->next->prev = new; new -> prev = p; p -> next = new; } prevnext payload prevnext payload prevnext payload

8. More on Data Structures in C CS-2301 D-term 20098 AddAfter(item *p, item *new) Simple linked list {new -> next = p -> next; p -> next = new; } Doubly-linked list {new -> next = p -> next; if (p -> next) p->next->prev = new; new -> prev = p; p -> next = new; } prevnext payload prevnext payload prevnext payload

9. More on Data Structures in C CS-2301 D-term 20099 AddAfter(item *p, item *new) Simple linked list {new -> next = p -> next; p -> next = new; } Doubly-linked list {new -> next = p -> next; if (p -> next) p->next->prev = new; new -> prev = p; p -> next = new; } prevnext payload prevnext payload prevnext payload

10. More on Data Structures in C CS-2301 D-term 200910 deleteNext(item *p) Simple linked list {if (p->next != NULL) p->next = p->next-> next; } Doubly-linked list Complicated Easier to deleteItem

11. More on Data Structures in C CS-2301 D-term 200911 deleteItem(item *p) Simple linked list Not possible without having a pointer to previous item! Doubly-linked list {if(p->next != NULL) p->next->prev = p->prev; if(p->prev != NULL) p->prev->next = p->next; } prevnext payload prevnext payload prevnext payload

12. More on Data Structures in C CS-2301 D-term 200912 deleteItem(item *p) Simple linked list Not possible without having a pointer to previous item! Doubly-linked list {if(p->next != NULL) p->next->prev = p->prev; if(p->prev != NULL) p->prev->next = p->next; } prevnext payload prevnext payload prevnext payload

13. More on Data Structures in C CS-2301 D-term 200913 deleteItem(item *p) Simple linked list Not possible without having a pointer to previous item! Doubly-linked list {if(p->next != NULL) p->next->prev = p->prev; if(p->prev != NULL) p->prev->next = p->next; } prevnext payload prevnext payload prevnext payload

14. More on Data Structures in C CS-2301 D-term 200914 Special Cases of Linked Lists Queue:– –Items always added to tail –Items always removed from head Stack:– –Items always added to head –Items always removed from head Singly-linked list works okay Need pointers to head and tail Singly-linked list works okay Only need pointer to head

15. More on Data Structures in C CS-2301 D-term 200915 Bubble Sort a Linked List item *BubbleSort(item *p) { if (p->next != NULL) { item *q = p->next, *qq = p; for (;q != NULL; qq = q, q = q->next) if (p->payload > q->payload){ /*swap p and q */ } p->next = BubbleSort(p->next); }; return p; }

16. More on Data Structures in C CS-2301 D-term 200916 Bubble Sort a Linked List item *BubbleSort(item *p) { if (p->next != NULL) { item *q = p->next, *qq = p; for (;q != NULL; qq = q, q = q->next) if (p->payload > q->payload){ item *temp = p->next; p->next = q->next; q->next = temp; qq->next = p; p = q; } p->next = BubbleSort(p->next); }; return p; }

17. More on Data Structures in C CS-2301 D-term 200917 Bubble Sort a Linked List item *BubbleSort(item *p) { if (p->next != NULL) { item *q = p->next, *qq = p; for (;q != NULL; qq = q, q = q->next) if (p->payload > q->payload){ item *temp = p->next; p->next = q->next; q->next = temp; qq->next = p; p = q; } p->next = BubbleSort(p->next); }; return p; } Head of (sub)list being sortedPointer to step thru (sub)list Pointer to item previous to q in (sub)list

18. More on Data Structures in C CS-2301 D-term 200918 Potential Exam Questions Analyze BubbleSort to determine if it is correct, and fix it if incorrect. Hint: you need to define “correct” Hint2: you need to define a loop invariant to convince yourself Draw a diagram showing the nodes, pointers, and actions of the algorithm

19. More on Data Structures in C CS-2301 D-term 200919 Observations:– What is the order (Big-O notation) of the Bubble Sort algorithm? Answer: O(n 2 ) Note that Quicksort is faster – O(n log n) on average Pages 87 & 110 in Kernighan and Ritchie Potential exam question:– why?

20. More on Data Structures in C CS-2301 D-term 200920 Questions?

21. More on Data Structures in C CS-2301 D-term 200921 Binary Tree (review) A linked list but with two links per item struct treeItem { type payload; treeItem *left; treeItem *right; }; leftright payload leftright payload leftright payload leftright payload leftright payload leftright payload leftright payload

22. More on Data Structures in C CS-2301 D-term 200922 Binary Trees (continued) Two-dimensional data structure Easy to grow and shrink Easy to add and delete items at leaves More work needed to insert or delete branch nodes Search time is O(log n) If tree is reasonably balanced Degenerates to O(n) in worst case if unbalanced

23. More on Data Structures in C CS-2301 D-term 200923 Order of Traversing Binary Trees In-order Traverse left sub-tree (in-order) Visit node itself Traverse right sub-tree (in-order) Pre-order Visit node first Traverse left sub-tree Traverse right sub-tree Post-order Traverse left sub-tree Traverse right sub-tree Visit node last

24. More on Data Structures in C CS-2301 D-term 200924 Order of Traversing Binary Trees In-order Traverse left sub-tree (in-order) Visit node itself Traverse right sub-tree (in-order) Pre-order Visit node first Traverse left sub-tree Traverse right sub-tree Post-order Traverse left sub-tree Traverse right sub-tree Visit node last Programming Assignment #6

25. More on Data Structures in C CS-2301 D-term 200925 Example of Binary Tree x = (a.real*b.imag - b.real*a.imag) / sqrt(a.real*b.real – a.imag*b.imag) = x/ sqrt - **.. arealbimag.. brealaimag - …

26. More on Data Structures in C CS-2301 D-term 200926 Question What kind of traversal order is required for this expression? In-order? Pre-order? Post-order?

27. More on Data Structures in C CS-2301 D-term 200927 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

28. More on Data Structures in C CS-2301 D-term 200928 Questions about Trees? or about Programming Assignment 6?

29. More on Data Structures in C CS-2301 D-term 200929 New Challenge What if we require a data structure that has to be accessed by value in constant time? I.e., O(log n) is not good enough! Need to be able to add or delete items Total number of items unknown But an approximate maximum might be known

30. More on Data Structures in C CS-2301 D-term 200930 Examples Anti-virus scanner Symbol table of compiler Virtual memory tables in operating system Bank account for an individual

31. More on Data Structures in C CS-2301 D-term 200931 Observation Arrays provide constant time access … … but you have to know which element you want! We only know the contents of the item we want! Also Not easy to grow or shrink Not open-ended Can we do better?

32. More on Data Structures in C CS-2301 D-term 200932 Answer – Hash Table Definition:– Hash Table A data structure comprising an array (for constant time access) A set of linked lists (one list for each array element) A hashing function to convert search key to array index

33. More on Data Structures in C CS-2301 D-term 200933 Definition Search key:– a value stored as (part of) the payload of the item you are looking for Need to find the item containing that value (i.e., key)

34. More on Data Structures in C CS-2301 D-term 200934 Answer – Hash Table Definition:– Hash Table A data structure comprising an array (for constant time access) A set of linked lists (one list for each array element) A hashing function to convert search key to array index Definition:– Hashing function (or simply hash function) A function that takes the search key in question and “randomizes” it to produce an index So that non-randomness of keys avoids concentration of too many elements around a few indices in array See §6.6 in Kernighan & Ritchie

35. More on Data Structures in C CS-2301 D-term 200935 data next Hash Table Structure item... data next data next data next data next data next data next data next data next data next data next data next data next

36. More on Data Structures in C CS-2301 D-term 200936 Guidelines for Hash Tables Lists from each item should be short I.e., with short search time (approximately constant) Size of array should be based on expected # of entries Err on large side if possible Hashing function Should “spread out” the values relatively uniformly Multiplication and division by prime numbers usually works well

37. More on Data Structures in C CS-2301 D-term 200937 Example Hashing Function P. 144 of K & R #define HASHSIZE 101 unsigned int hash(char *s) { unsigned int hashval; for (hashval = 0; *s != ‘\0’; s++) hashval = *s + 31 * hashval; return hashval % HASHSIZE }

38. More on Data Structures in C CS-2301 D-term 200938 Example Hashing Function P. 144 of K & R #define HASHSIZE 101 unsigned int hash(char *s) { unsigned int hashval; for (hashval = 0; *s != ‘\0’; s++) hashval = *s + 31 * hashval; return hashval % HASHSIZE } Note choice of prime numbers to “mix it up”

39. More on Data Structures in C CS-2301 D-term 200939 Using a Hash Table struct item *lookup(char *s) { struct item *np; for (np = hashtab[hash(s)]; np != NULL; np = np -> next) if (strcmp(s, np->data) == 0) return np; /*found*/ return NULL;/* not found */ }

40. More on Data Structures in C CS-2301 D-term 200940 Using a Hash Table struct item *lookup(char *s) { struct item *np; for (np = hashtab[hash(s)]; np != NULL; np = np -> next) if (strcmp(s, np->data) == 0) return np; /*found*/ return NULL;/* not found */ } Hash table is indexed by hash value of s

41. More on Data Structures in C CS-2301 D-term 200941 Using a Hash Table struct item *lookup(char *s) { struct item *np; for (np = hashtab[hash(s)]; np != NULL; np = np -> next) if (strcmp(s, np->data) == 0) return np; /*found*/ return NULL;/* not found */ } Traverse the linked list to find item s

42. More on Data Structures in C CS-2301 D-term 200942 Using a Hash Table (continued) struct item *addItem(char *s, …) { struct item *np; unsigned int hv; if ((np = lookup(s)) == NULL) { np = malloc(item); /* fill in s and data */ np -> next = hashtab[hv = hash(s)]; hashtab[hv] = np; }; return np; }

43. More on Data Structures in C CS-2301 D-term 200943 Using a Hash Table (continued) struct item *addItem(char *s, …) { struct item *np; unsigned int hv; if ((np = lookup(s)) == NULL) { np = malloc(item); /* fill in s and data */ np -> next = hashtab[hv = hash(s)]; hashtab[hv] = np; }; return np; } Inserts new item at head of the list indexed by hash value

44. More on Data Structures in C CS-2301 D-term 200944 Hash Table Summary Widely used for constant time access Easy to build and maintain There exist an art and science to the choice of hashing functions Consult textbooks, web, etc.

45. More on Data Structures in C CS-2301 D-term 200945 Questions?