1. 1 240-222 CPT: Lists/15 240-222 Computer Programming Techniques Semester 1, 1998 Objective of these slides: –to describe linked lists in C 15. Lists

2. 2 240-222 CPT: Lists/15 Overview 1. List Data Structures and Operations 2. List Implementations 3. Dynamically Created Lists 4. Converting a String to a List 5. List Functions

3. 3 240-222 CPT: Lists/15 1. List Data Structures and Operations l Some possible operations: create/destroy a list test to see if a list is empty return the tail of the list insert/delete elements print a list calculate the length of a list

4. 4 240-222 CPT: Lists/15 2. List implementations Version 1: #define N 1000 /* the size of the list */ typedef char LIST[N]; LIST lt; /* same as char lt[N] */

5. 5 240-222 CPT: Lists/15 Version 2(Sec. 12.2) struct listnode { char data; struct listnode *nextptr; }; typedef struct listnode LISTNODE; LISTNODE elem; elem datanextptr

6. 6 240-222 CPT: Lists/15 Use LISTNODE a, b, c; a.data = 'a'; b.data = 'c'; c.data = 'e'; a.nextptr = b.nextptr = c.nextptr = NULL; continued abc

7. 7 240-222 CPT: Lists/15 a.nextptr = &b; b.nextptr = &c; printf("%c", a.nextptr->data); /* 'c' printed */ printf("%c", a.nextptr->nextptr->data); /* 'e' printed */ abc NULL ‘a’‘c’‘e’

8. 8 240-222 CPT: Lists/15 3. Dynamically Created Lists /* list implementation as before */ typedef LISTNODE *LNP; LNP head = NULL; head = malloc(sizeof(LISTNODE)); head->data = 'n'; head->nextptr = NULL; Function prototype in stdlib.h : void *malloc(size_t size); head ‘n’ NULL

9. 9 240-222 CPT: Lists/15 Add a second element head->nextptr = malloc(sizeof(LISTNODE)); head->nextptr->data = 'e'; head->nextptr->nextptr = NULL; head ‘n’‘e’ NULL

10. 10 240-222 CPT: Lists/15 Add a third element head->nextptr->nextptr = malloc(sizeof(LISTNODE)); head->nextptr->nextptr->data = 'w'; head->nextptr->nextptr->nextptr = NULL; head ‘n’‘e’‘w’ NULL

11. 11 240-222 CPT: Lists/15 4. Converting a String to a List #include #include /* list type implementation */ LNP string_to_list(char []); int main() { LNP h = NULL; h = string_to_list("AB"); return 0; } /* implementation of string_to_list() */

12. 12 240-222 CPT: Lists/15 LNP string_to_list(char s[]) { LNP head = NULL, tail; int i; if (s[0] != '\0') { head = malloc(sizeof(LISTNODE)); head->data = s[0]; tail = head; for (i=1; s[i] != '\0'; i++){ tail->nextptr = malloc(sizeof(LISTNODE)); tail = tail->nextptr; tail->data = s[i]; } tail->nextptr = NULL; /* list end */ } return head; }

13. 13 240-222 CPT: Lists/15 string_to_list("AB") head = malloc(sizeof(LISTNODE)); head->data = s[0]; tail = head; head ‘A’ tail ‘?’

14. 14 240-222 CPT: Lists/15 tail->nextptr = malloc(sizeof(LISTNODE)); head ‘A’ tail ‘?’

15. 15 240-222 CPT: Lists/15 tail = tail->nextptr; tail->data = s[i]; /* i = 1 here */ head ‘A’ tail ‘?’‘B’

16. 16 240-222 CPT: Lists/15 s[2] = '\0' /* so end of list is assigned NULL */ head ‘A’ tail NULL ‘B’

17. 17 240-222 CPT: Lists/15 5. List Functions 5.1. Empty Lists 5.2. Return the First Element of a List 5.3. Produce the Tail of a List 5.4. Put an Element on the Front of a List 5.5. Insertion continued

18. 18 240-222 CPT: Lists/15 5.6. Deletion 5.7. List Membership 5.8. Print a List 5.9. List Length 5.10. Concatenate Two Lists

19. 19 240-222 CPT: Lists/15 5.1. Empty Lists Make an empty list: LNP h1; h1 = NULL; Test for emptiness: int isempty(LNP sptr) { return (sptr == NULL); }

20. 20 240-222 CPT: Lists/15 5.2. Return the First Element of a List char first(LNP cptr) { if (isempty(cptr)) return '\0' else return cptr->data; }

21. 21 240-222 CPT: Lists/15 Use LNP head; char c; head = string_to_list("new"); c = first(head); /* c is 'n'; head is not altered */

22. 22 240-222 CPT: Lists/15 5.3. Produce the tail of a list void tail(LNP *cptr) { LNP temp; if (isempty(*cptr)) printf("The list is empty.\n\n"); else { temp = *cptr; *cptr = (*cptr)->nextptr; free(temp); } } l cptr is the address of a pointer, so that the pointer can be modified using "call by reference".

23. 23 240-222 CPT: Lists/15 Use LNP head; head = string_to_list("new"); : tail(&head); /* head is now the list version of “ew” */

24. 24 240-222 CPT: Lists/15 5.4. Put an Element on the List Front LNP cons(char c, LNP cptr) { LNP temp; temp = malloc(sizeof(LISTNODE)); temp->data = c; temp->nextptr = cptr; return temp; }

25. 25 240-222 CPT: Lists/15 Use LNP h1, h2; h1 = string_to_list("ew"); h2 = cons('n', h1); Before the cons() call: h1 ‘e’‘w’ NULL

26. 26 240-222 CPT: Lists/15 h2 ‘n’‘e’‘w’ NULL After: h1

27. 27 240-222 CPT: Lists/15 5.5. Insertion head ‘n’‘w’ Before: previousptrcurrentptr NULL newptr ‘o’ NULL

28. 28 240-222 CPT: Lists/15 head ‘n’‘o’‘w’ NULL After:

29. 29 240-222 CPT: Lists/15 Code Fig. 12.3 void insert(LNP *sptr, char value) { LNP newptr, previousptr, currentptr; newptr = malloc(sizeof(LISTNODE)); if (newptr) { newptr->data = value; newptr->nextptr = NULL; previousptr = NULL; currentptr = *sptr; continued

30. 30 240-222 CPT: Lists/15 while ((currentptr != NULL) && (value > currentptr->data)) { previousptr = currentptr; currentptr = currentptr->nextptr; } if (previousptr == NULL) { newptr->nextptr = *sptr; *sptr = newptr; } else { previousptr->nextptr = newptr; newptr->nextptr = currentptr; } } else printf("No memory available.\n"); }

31. 31 240-222 CPT: Lists/15 Note l The use of a pointer address (sptr) as an argument to insert() is to allow the head pointer to the list to be altered if the character is inserted as the first node.

32. 32 240-222 CPT: Lists/15 Use LNP h1; h1 = string_to_list("nw"); insert(&hl, 'o'); Dangers: LNP h1, h2; h1 = string_to_list("nw"); h2 = h1; insert(&hl, 'o');

33. 33 240-222 CPT: Lists/15 5.6. Deletion LNP head; head = string_to_list("new"); c = delete(&head, 'e'); head ‘n’ previousptrcurrentptr ‘e’‘w’ NULL

34. 34 240-222 CPT: Lists/15 head ‘n’ previousptrcurrentptr ‘e’‘w’ NULL tempptr

35. 35 240-222 CPT: Lists/15 Code Fig. 12.3 char delete(LNP *sptr, char value) { LNP previousptr, currentptr, tempptr; if (value == (*sptr)->data) { tempptr = *sptr; *sptr = (*sptr)->nextptr; free(tempptr); return value; } else { previousptr = *sptr; currentptr = (*sptr)->nextptr; continued

36. 36 240-222 CPT: Lists/15 while ((currentptr != NULL) && (currentptr->data != value)) { previousptr = currentptr; currentptr = currentptr->nextptr; } if (currentptr) { tempptr = currentptr; previousptr->nextptr = currentptr->nextptr; free(tempptr); return value; } } return '\0'; }

37. 37 240-222 CPT: Lists/15 Some Comments l The use of a pointer address (sptr) as an argument to delete() is to allow the head pointer to the list to be altered if the first character in the list is being deleted.

38. 38 240-222 CPT: Lists/15 l delete() can stop when: –1. It has found the character. –2. It has reached the end of the list (the character isn't there). –3. It has reached a character lexically bigger than the one being sought. Not used in this code.

39. 39 240-222 CPT: Lists/15 Dangers LNP h1, h2; char c; h1 = string_to_list("all"); h2 = h1; c = delete(&h1, 'l'); h2 would be pointing at nothing if the first node of h1 was deleted h1 ‘a’‘l’ NULL h2

40. 40 240-222 CPT: Lists/15 5.7. List Membership int member(char c, LNP cptr) { if (isempty(cptr)) return 0; else { if (c == first(cptr)) return 1; else return member(c, cptr->nextptr); } }

41. 41 240-222 CPT: Lists/15 5.8. Print a List (iteratively) Fig. 12.3 void printList(LNP cptr) { if (!cptr) printf("List is empty.\n\n"); else { printf("The list is:\n"); while (cptr) { printf("%c --> ", cptr->data); cptr = cptr->nextptr; } printf("NULL\n\n"); } }

42. 42 240-222 CPT: Lists/15 Use LNP head; head = string_to_list("old"); printList(head); The list is: o --> l --> d --> NULL

43. 43 240-222 CPT: Lists/15 Print a List (recursively) void printList(LNP cptr) { if (isempty(cptr)) printf("NULL"); else { printf("%c --> ", first(cptr)); printList(cptr->nextptr); } }

44. 44 240-222 CPT: Lists/15 5.9. List Length int length(LNP cptr) { if (isempty(cptr)) return 0; else return (1 + length(cptr->nextptr)); }

45. 45 240-222 CPT: Lists/15 5.10. Concatenate Two Lists void concat(LNP a, LNP b) { if (a->nextptr == NULL) a->nextptr = b; else concat(a->nextptr, b); }

46. 46 240-222 CPT: Lists/15 Use LNP h1, h2; h1 = string_to_list("new"); h2 = string_to_list("ton"); concat(h1, h2); /* h1 altered */ print_list(h1); The list is: n --> e --> w --> t --> o --> n --> NULL

47. 47 240-222 CPT: Lists/15 Dangers LNP h1, h2; h1 = string_to_list("ab"); h2 = string_to_list("cd"); concat(h1, h2); /* h1 is list "abcd" */ h2->data = 'o'; h1 ‘a’‘o’‘d’ NULL ‘b’ h2