More on Data Structures in C

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

2. 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) More on Data Structures in C

3. payload payload payload payload next next next next Linked List (continued) struct listItem *head; More on Data Structures in C

4. payload payload payload payload prev prev prev prev next next next next Doubly-Linked List (review) struct listItem *head, *tail; More on Data Structures in C

5. 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; } AddAfter(item *p, item *new) More on Data Structures in C

6. 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; } payload payload payload prev prev prev next next next AddAfter(item *p, item *new) More on Data Structures in C

7. 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; } payload payload payload prev prev prev next next next AddAfter(item *p, item *new) More on Data Structures in C

8. 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; } payload payload payload prev prev prev next next next AddAfter(item *p, item *new) More on Data Structures in C

9. 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; } payload payload payload prev prev prev next next next AddAfter(item *p, item *new) More on Data Structures in C

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

11. 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; } payload payload payload prev prev prev next next next deleteItem(item *p) More on Data Structures in C

12. 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; } payload payload payload prev prev prev next next next deleteItem(item *p) More on Data Structures in C

13. 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; } payload payload payload prev prev prev next next next deleteItem(item *p) More on Data Structures in C

14. Singly-linked list works okay • Need pointers to head and tail • Singly-linked list works okay • Only need pointer to head 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 More on Data Structures in C

15. 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; } More on Data Structures in C

16. 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; } More on Data Structures in C

17. Head of (sub)list being sorted Pointer to step thru (sub)list Pointer to item previous to q in (sub)list 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; } More on Data Structures in C

18. 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 More on Data Structures in C

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

20. Questions? More on Data Structures in C

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

22. 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 More on Data Structures in C

23. 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 More on Data Structures in C

24. Programming Assignment #6 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 More on Data Structures in C

25. 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 More on Data Structures in C

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

27. 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 More on Data Structures in C

28. Questions about Trees? or aboutProgramming Assignment 6? More on Data Structures in C

29. New Challenge • What if we require a data structure that has to be accessed by value in constanttime? • 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 More on Data Structures in C

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

31. 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? More on Data Structures in C

32. 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 More on Data Structures in C

33. 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) More on Data Structures in C

34. 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 More on Data Structures in C

35. item item item item item ... item item item item item data data data data data data data data data data data data data next next next next next next next next next next next next next Hash Table Structure More on Data Structures in C

36. 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 More on Data Structures in C

37. 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 } More on Data Structures in C

38. Example Hashing Function Note choice of prime numbers to “mix it up” • 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 } More on Data Structures in C

39. 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 */ } More on Data Structures in C

40. Hash table is indexed by hash value of s 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 */ } More on Data Structures in C

41. Traverse the linked list to find item s 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 */ } More on Data Structures in C

42. 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; } More on Data Structures in C

43. Inserts new item at head of the list indexed by hash value 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; } More on Data Structures in C

44. 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. More on Data Structures in C

45. Questions? More on Data Structures in C