1 / 73

Chapter #4: LISTS

Chapter #4: LISTS. Pointers. array - sequential representation - some operation can be very time- consuming (data movement) - size of data must be predefined - static storage allocation and deallocation solution to the data movement in sequential representation

soren
Download Presentation

Chapter #4: LISTS

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter #4: LISTS

  2. Pointers • array • - sequential representation • - some operation can be very time- • consuming (data movement) • - size of data must be predefined • - static storage allocation and • deallocation • solution to the data movement in sequential representation • - pointers: often called links

  3. Pointers • for any type T in C • - there is corresponding type • pointer-to-T • actual value of pointer type • - an address of memory • pointer operators in C • - the address operator: & • - the dereferencing(or indirection) • operator: *

  4. Pointers • dynamically allocated storage • - C provides a mechanism, called a • heap, for allocating storage at • run-time • int i,*pi; • float f,*pf; • pi = (int *)malloc(sizeof(int)); • pf = (float *)malloc(sizeof(float)); • *pi = 1024; • *pf = 3.14; • printf(“an integer=%d,a float=%f\n”,*pi,*pf); • free(pi); • free(pf);

  5. 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

  6. ptr bat cat sat vat NULL mat Singly Linked Lists • to insert the word mat between cat and sat • 1)get a node currently unused(paddr) • 2)set the data of this node 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

  7. 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

  8. Singly Linked Lists • required capabilities to make linked representations possible • - a mechanism for defining a node’s • structure, that is, the field it • contains • - a way to create new nodes when we • need them • - a way to remove nodes that we no • longer need

  9. 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 { • char data[4]; • struct List_Node *link; • } list_node; • typedef struct list_node *list_ptr; • list_ptr ptr = NULL;

  10. b a t \0 Singly Linked Lists • create new nodes for out 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

  11. 10 Singly Linked Lists • Ex 4.2 [two-node linked list] • create a linked list of integers • #include <stdio.h> • struct List_Node { • int data; • struct List_Node *link; • }; • typedef struct List_Node list_node; • typedef struct List_Node *list_ptr; • main() • { • list_node first = { 10, NULL}; • list_ptr ptr = &first; • } ptr first.data first.link NULL ptr->data ptr->link

  12. 10 20 NULL Singly Linked Lists • main() • { • list_node first = { 10, NULL}; • list_ptr ptr = &first; • list_node second = { 20, NULL}; • first.link = &second; • } ptr first second

  13. 10 10 20 20 NULL NULL 50 Singly Linked Lists • Ex 4.3 [list insertion] • determine if we have used all available memory: IS_FULL ptr ptr node temp

  14. Singly Linked Lists • main() • { • list_node first = { 10, NULL}; • list_ptr ptr = &first; • list_node second = { 20, NULL}; • first.link = &second; • insert(&first) • } • void insert(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; • temp->link = node->link; • node->link = temp; • }

  15. Singly Linked Lists • Ex 4.4 [list deletion] • deletion depends on the location of the node: more complicated • assumption • - 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

  16. 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 • 1) the node to be deleted is the • first node in the list • 2) otherwise ptr trail node ptr (a) before deletion (b) after deletion

  17. Singly Linked Lists • main() • { • list_node first = { 10, NULL}; • list_ptr ptr = &first; • list_node second = { 20, NULL}; • first.link = &second; • insert(&first) • delete(&ptr, &first, first.link); • } • void delete(list_ptr *pptr, list_ptr trail, • list_ptr node) • { • if(trail) • trail->link = node->link; • else • *pptr = (*pptr)->link; • free(node); • }

  18. Singly Linked Lists • Ex 4.5 [printing out a list] • while not end of the list do • print out data field; • move to the next node; • end; • void print_list(list_ptr ptr) { • printf(“The list contains: “); • for(; ptr; ptr = ptr->link) • printf(“%4d”, ptr->data); • printf(“\n”); • }

  19. top element link ······ NULL front rear element link ······ NULL Dynamically Linked stacks And Queues • representing stack / queue by linked list (a) linked stack (b) linked queue

  20. Dynamically Linked Stacks And Queues • representing n stacks by linked lists • #define MAX_STACKS 10 /* n=MAX_STACKS=10 */ • typedef struct { • int key; • /* other fields */ • } element; • struct Stack { • element item; • struct Stack *link; • }; • typedef struct Stack stack; • typedef struct Stack *stack_ptr; • stack_ptr top[MAX_STACKS];

  21. top[0] element link key ······ NULL top[1] ······ NULL top[MAX_STACKS-1] ······ NULL Dynamically Linked Stacks And Queues · · ·

  22. Dynamically Linked stacks And Queues • initial condition for stacks • top[i] = NULL, 0 £ i < MAX_STAKCS • boundary condition for n stacks • - empty condition: • top[i] = NULL iff the ith stack is empty • - full condition: • IS_FULL(temp) iff the memory is full

  23. Dynamically Linked Stacks And Queues • add to a linked stack • … • push( &top[stack_no], item_x); • … • 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; • }

  24. Dynamically Linked Stacks And Queues • delete from a linked stack • … • item_x = pop(&top[stack_no]); • … • 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; • }

  25. Dynamically Linked Stacks And Queues • representing m queues by linked lists • #define MAX_QUEUES 10 /* m=MAX_QUEUES=10 */ • struct queue { • element item; • struct queue *link; • }; • typedef struct queue *queue_ptr; • queue_ptr front[MAX_QUEUES],rear[MAX_QUEUES];

  26. front[0] rear[0] element link key ······ NULL front[1] rear[1] ······ NULL front[MAX_QUEUES-1] rear[MAX_QUEUES-1] ······ NULL Dynamically Linked Stacks And Queues · · ·

  27. Dynamically Linked Stacks And Queues • initial conditon for queues • front[i]=NULL,0 £i < MAX_QUEUES • boundary condition for queues • - empty condition: • front[i]= NULL iff the ith queue is empty • - full condition: • IS_FULL(temp) iff the memory is full

  28. Dynamically LinkedStacks And Queues • add to the rear of a linked queue • void insert(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; • }

  29. Dynamically Linked Stacks And Queues • delete from the front of a linked queue • element delete(queue_ptr *pfront) { • queue_ptr temp=*pfront; • element item; • if (IS_EMPTY(*front)) { • fprintf(stderr,”The queue is empty\n”); • exit(1); • } • item=temp->item; • *pfront=temp->link; • free(temp); • return item; • }

  30. Dynamically Linked Stacks And Queues • representing stacks/queues by linked • lists • - no data movement is necessary : • O(1) • - no full condition check is • necessary • - size is growing and shrinking • dynamically

  31. 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;

  32. coef expon link a 3 14 2 8 1 0 NULL b 8 14 -3 10 10 6 NULL Polynomials • poly_node • a = 3x14 + 2x8 + 1 • b = 8x14 - 3x10 + 10x6

  33. 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

  34. 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

  35. 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

  36. 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

  37. 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;

  38. 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; • (to be continued)

  39. Polynomials • 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; • } • (to be continued)

  40. Polynomials • 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; • }

  41. 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; • }

  42. 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)

  43. Polynomials • erasing polynomials • e(x) = a(x) * b(x) + d(x) • poly_ptr a, b, d, e; • ··· • a = read_poly(); • b = read_poly(); • d = read_poly(); • temp = pmult(a, b); • e = padd(temp, d); • print_poly(e);

  44. 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)

  45. 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 freed nodes storage pool 1 2 n avail ······ initial available space list

  46. 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; • }

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

  48. 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 term - how to erase polynomial efficiently? how to return n used nodes to storage pool ?

  49. 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

  50. 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)

More Related