Chapter 4. LISTS

1. Chapter 4. LISTS Horowitz, Sahni, and Anderson-Freed Fundamentals of Data Structures in C, 2nd Edition Computer Science Press, 2008 Fall 2009 Course, Sungkyunkwan University Hyunseung Choo choo@ece.skku.ac.kr

2. ptr bat cat sat vat NULL Singly Linked Lists • compose of data part and link part • link part contains address of the next element in a list • non-sequential representations • size of the list is not predefined • dynamic storage allocation and deallocation

3. ptr bat cat sat vat NULL mat Singly Linked Lists • To insert the word mat between cat and sat 1) get a currently unused node (paddr) 2) set paddr’s data to mat 3) set paddr’s link to point to the address found in the link of the node cat 4) set the link of the node cat to point to paddr

4. ptr bat cat mat sat vat NULL Singly Linked Lists • To delete mat from the list 1) find the element that immediately precedes mat, which is cat 2) set its link to point to mat’s link • no data movement in insert and delete operation

5. Singly Linked Lists • Ex 4.1 [list of words ending in at] • define a node structure for the list • data field: character array • link field: pointer to the next node • self-referential structure typedef struct list_node *list_ptr; typedef struct list_node { char data[4]; list_ptr link; }; list_ptr ptr = NULL;

6. b a t \0 Singly Linked Lists • Create a new node for our list then place the word bat into our list ptr=(list_ptr)malloc(sizeof(list_node)); strcpy(ptr->data,”bat”); ptr->link=NULL; address of first node ptr->data ptr->link NULL ptr

7. ptr 10 20 NULL Singly Linked Lists • Ex 4.2 [two-node linked list] • create a linked list of integers typedef struct list_node *list_ptr; typedef struct list_node { int data; list_ptr link; }; list_ptr ptr = NULL;

8. Singly Linked Lists list_ptr create2() { list_ptr first, second; first = (list_ptr)malloc(sizeof(list_node)); second = (list_ptr)malloc(sizeof(list_node)); second->link=NULL; second->data=20; first->data=10; first->link=second; return first; }

9. 10 20 NULL 50 Singly Linked Lists • Ex 4.3 [list insertion] • determine if we have used all available memory: IS_FULL #define IS_FULL(ptr) (!(ptr)) • Function call: insert(&ptr, node); ptr node temp

10. Singly Linked Lists void insert (list_ptr *pptr,list_ptr node) { list_ptr temp; temp=(list_ptr)malloc(sizeof(list_node)); if(IS_FULL(temp)) { fprintf(stderr,”The momory is full\n”); exit(1); } temp->data=50; if (*pptr) { temp->link = node->link; node->link = temp; } else { temp->link = NULL; *pptr = temp; } }

11. ptr node trail = NULL ptr 10 50 20 50 20 NULL NULL (a) before deletion (b) after deletion 10 50 20 10 20 NULL NULL Singly Linked Lists • Ex 4.4 [list deletion] • ptr: point to the start of list • node: point to the node to be deleted • trail: point to the node that precedes node to be deleted delete(&ptr,NULL,ptr); delete(&ptr,ptr,ptr->link); ptr trail node ptr (a) before deletion (b) after deletion

12. Singly Linked Lists void delete(list_ptr *pptr, list_ptr trail, list_ptr node) { if (trail) trail->link = node->link; else *pptr = (*pptr)->link; free(node); } • delete(&ptr,NULL,ptr); delete(&ptr,ptr,ptr->link); • Ex 4.5 [printing out a list] void print_list(list_ptr ptr) { printf(“The list contains: “); for(; ptr; ptr = ptr->link) printf(“%4d”, ptr->data); printf(“\n”); }

13. top element link ······ NULL front rear element link ······ NULL Dynamically Linked Stacks And Queues #define MAX_STACKS 10 /* n=MAX_STACKS=10 */ typedef struct { int key; /* other fields here */ } element; typedef struct stack *stack_ptr; typedef struct stack { element item; stack_ptr link; }; stack_ptr top[MAX_STACKS]; (a) linked stack (b) linked queue

14. top[0] element link key ······ NULL top[MAX_STACKS-1] ······ NULL Dynamically Linked Stacks And Queues · · · initial condition for n stacks top[i] = NULL, 0 ≤ i < MAX_STACKS boundary conditions top[i]==NULL iff the ith stack is empty IS_FULL(temp) iff the memory is full

15. Dynamically Linked Stacks And Queues • Add to a linked stack void push(stack_ptr *ptop, element item) { stack_ptr temp = (stack_ptr)malloc(sizeof (stack)); if(IS_FULL(temp)) { fprintf(stderr,”The memory is full\n”); exit(1); } temp->item=item; temp->link=*ptop; *ptop = temp; } • #define IS_FULL(ptr) (!(ptr)) • push(&top[stack_no], item);

16. Dynamically Linked Stacks And Queues • Delete from a linked stack element pop(stack_ptr *ptop) { stack_ptr temp = *ptop; element item; if(IS_EMPTY(temp)) { fprintf(stderr,”The stack is empty\n”); exit(1); } item=temp->item; *ptop=temp->link; free(temp); return item; } • #define IS_EMPTY(ptr) (!(ptr)) • item=pop(&top[stack_no]);

17. front rear element link ······ NULL Dynamically Linked Stacks And Queues #define MAX_QUEUES 10 /* m=MAX_QUEUES=10 */ typedef struct queue *queue_ptr; typedef struct queue { element item; queue_ptr link; }; queue_ptr front[MAX_QUEUES],rear[MAX_QUEUES]; (b) linked queue

18. front[0] rear[0] element link key ······ NULL front[MAX_QUEUES-1] rear[MAX_QUEUES-1] ······ NULL Dynamically Linked Stacks And Queues · · · initial conditon for n queues front[i]=NULL, 0 £i < MAX_QUEUES boundary conditions front[i]==NULL iff the ith queue is empty IS_FULL(temp) iff the memory is full

19. Dynamically Linked Stacks And Queues • Add to the rear of a linked queue void addq(queue_ptr *pfront, queue_ptr *prear, element item) { queue_ptr temp = (queue_ptr)malloc(sizeof(queue)); if(IS_FULL(temp)) { fprintf(stderr,”The memory is full\n”); exit(1); } temp->item=item; temp->link=NULL; if (*pfront) (*prear)->link=temp; else *pfront = temp; *prear = temp; } • addq(&front[queue_no], &rear[queue_no], item);

20. Dynamically Linked Stacks And Queues • Delete from the front of a linked queue element deleteq(queue_ptr *pfront) { queue_ptr temp=*pfront; element item; if (IS_EMPTY(*pfront)) { fprintf(stderr,”The queue is empty\n”); exit(1); } item=temp->item; *pfront=temp->link; free(temp); return item; } • item=deleteq(&front[queue_no]); • comparison: array vs. linked list

21. coef expon link a 3 14 2 8 1 0 NULL b 8 14 -3 10 10 6 NULL Polynomials • Representing polynomials as singly linked lists • A(x) = am-1xem-1 + ··· + a0xe0 typedef struct poly_node *poly_ptr; typedef struct poly_node { int coef; int expon; poly_ptr link; }; poly_ptr a,b,d; poly_node a = 3x14 + 2x8 + 1 b = 8x14 - 3x10 + 10x6

22. 3 14 2 8 1 0 NULL a 8 14 -3 10 10 6 NULL b 11 14 NULL d rear Polynomials • Adding polynomials • (a) a->expon == b->expon

23. 3 14 2 8 1 0 NULL a 8 14 -3 10 10 6 NULL b 11 14 -3 10 NULL d rear Polynomials • (b) a->expon < b->expon

24. 3 14 2 8 1 0 NULL a 8 14 -3 10 10 6 NULL b 11 14 -3 10 2 8 NULL d rear Polynomials • (c) a->expon > b->expon

25. 3 14 2 8 1 0 NULL a 8 14 -3 10 10 6 NULL b 11 14 -3 10 2 8 d 10 6 NULL rear Polynomials • (d) a->expon < b->expon

26. 3 14 2 8 1 0 NULL a 8 14 -3 10 10 6 NULL b 11 14 -3 10 2 8 d 10 6 1 0 NULL rear Polynomials • (e) b == NULL;

27. Polynomials poly_ptr padd(poly_ptr a,poly_ptr b) { poly_ptr front,rear,temp; int sum; rear=(poly_ptr)malloc(sizeof(poly_node)); if(IS_FULL(rear)) { fprintf(stderr,”The memory is full\n”); exit(1);} front = rear; while(a && b) switch(COMPARE(a->expon,b->expon)) { case -1: /* a->expon < b->expon */ attach(b->coef,b->expon,&rear); b = b->link; break; case 0: /* a->expon = b->expon */ sum = a->coef + b->coef; if(sum) attach(sum,a->expon,&rear); a = a->link; b = b->link; break; case 1: /* a->expon > b->expon */ attach(a->coef,a->expon,&rear); a = a->link; }

28. Polynomials poly_ptr padd(poly_ptr a,poly_ptr b) { · · · (continued from the previous slide) for(; a; a=a->link) attach(a->coef,a->expon,&rear); for(; b; b=b->link) attach(b->coef,b->expon,&rear); rear->link = NULL; temp=front; front=front->link; free(temp); return front; }

29. Polynomials • Function attach() to create a new node and append it to the end of d void attach(float coe, int exp, poly_ptr *pptr) { poly_ptr temp; temp=(poly_ptr)malloc(sizeof(poly_node)); if(IS_FULL(temp)) { fprintf(stderr,”The memory is full\n”); exit(1); } temp->coef = coe; temp->expon = exp; (*pptr)->link = temp; *pptr=temp; }

30. Polynomials • Analysis of padd where • m, n : number of terms in each polynomial • coefficient additions: • O(min{m, n}) • exponent comparisons: • O(m + n) • creation of new nodes for d • O(m + n) • Time complexity: • O(m + n)

31. Polynomials • Erasing polynomials void erase(poly_ptr *pptr) { poly_ptr temp; while (*pptr) { temp = *pptr; *pptr = (*pptr)->link; free(temp); } } • useful to reclaim the nodes that are being used to represent partial result such as temp(x)

32. NULL Polynomials • Allocating/deallocating nodes • how to preserve free node in a storage pool? • initially link together all free nodes into a list in a storage pool • avail: variable of type poly_ptr that points to the first node in list of free nodes storage pool 1 2 n avail ······ initial available space list

33. Polynomials • Allocating nodes poly_ptr get_node(void) { poly_ptr node; if (avail) { node = avail; avail = avail->link; } else { node = (poly_ptr)malloc(sizeof(poly_node)); if (IS_FULL(node)) { fprintf(stderr,”The memory is full\n”); exit(1); } } return node; }

34. Polynomials • Deallocating nodes void ret_node(poly_ptr ptr) { ptr->link = avail; avail = ptr; }

35. Polynomials void erase(poly_ptr *pptr) { poly_ptr temp; while (*pptr) { temp = *pptr; *pptr = (*pptr)->link; ret_node(temp); } } • traverse to the last node in the list: • O(n) where n: number of terms • how to erase polynomial efficiently? • how to return n used nodes to storage pool?

36. Polynomials • Representing polynomials as circularly linked list • to free all the nodes of a polynomials more efficiently • modify list structure • the link of the last node points to the first node in the list • called circular list (« chain) ptr

37. Polynomials • Maintain our own list (as a chain) of nodes that has been freed • obtain effective erase algorithm void cerase(poly_ptr *pptr) { if (*pptr) { temp = (*pptr)->link; (*pptr)->link = avail; avail = temp; *pptr = NULL; } } • independent of the number of nodes in a list: O(1)

38. Polynomials • Circular list with head nodes • handle zero polynomials in the same way as nonzero polynomials (empty list) - - ptr head node - - ptr head node

39. Operations for Chains • Inverting (or reversing) a chain • “in place” by using three pointers • lead, middle, trail typedef struct list_node *list_ptr; typedef struct list_node { char data; list_ptr link; }; list_ptr invert(list_ptr lead) { list_ptr middle, trail; middle = NULL; while (lead) { trail = middle; middle = lead; lead = lead->link; middle->link = trail; } return middle; } time: O(length of the list)

40. middle lead NULL NULL trail middle lead NULL NULL trail middle lead Operations for Chains

41. trail middle lead trail middle lead trail middle lead Operations for Chains NULL NULL NULL NULL NULL NULL

42. Operations for Chains • Concatenates two chains • produce a new list that contains ptr1 followed by ptr2 list_ptr concat(list_ptr ptr1,list_ptr ptr2) { list_ptr temp; if (IS_EMPTY(ptr1)) return ptr2; else { if (!IS_EMPTY(ptr2)) { for (temp=ptr1; temp->link; temp=temp->link); temp->link = ptr2; } return ptr1; } }

43. Operations for Chains • Finding the length of a list(chain) int length(list_ptr ptr) { int count = 0; while (ptr) { count++; ptr = ptr->link; } return count; } • Insert a new node at the front or at the rear of the chain • front-insert: O(1), • rear-insert: O(n) ptr x1 x2 x3 NULL

44. Operations for Chains • Insert a new node at the front of a list(chain) void insert_front(list_ptr *pptr, list_ptr node) { if (IS_EMPTY(*pptr)) { *pptr = node; node->link = NULL; } else { node->link = *pptr; *pptr = node; } }

45. Operations for Circularly Linked Lists • (singly) circular linked lists • Insert a new node at the front or at the rear • move down the entire length of ptr to insert at both front and rear: • insert-front : O(n) • insert-rear : O(n) x1 x2 x3 ptr

46. Operations for Circularly Linked Lists • improve this better: • make ptr points to the last node • insert a new node at the front or at the rear • front-insert : O(1) • rear-insert : O(1) x1 x2 x3 ptr

47. Operations for Circularly Linked Lists • Insert a new node at the front of a circular list void insert_front(list_ptr *pptr, list_ptr node) { if (IS_EMPTY(*pptr)) { *pptr = node; node->link = node; } else { node->link = (*pptr)->link; (*pptr)->link = node; *pptr = node; /* for rear-insert */ } }

48. Operations for Circularly Linked Lists • Finding the length of a circular list int length(list_ptr ptr) { list_ptr temp; int count = 0; if (ptr) { temp = ptr; do { count++; temp = temp->link; } while (temp != ptr); } return count; }

49. Doubly linked lists • Problems of singly linked lists • move to only one way direction • hard to find the previous node • hard to delete the arbitrary node • Doubly linked circular lists • doubly lists + circular lists • allow two links • two way direction

50. Doubly linked lists typedef struct node *node_ptr; typedef struct node { node_ptr llink; element item; node_ptr rlink; }; • suppose that ptr points to any node in a doubly linked list ptr = ptr->llink->rlink = ptr->rlink->llink