Pointers. Array. Solution to the data movement in sequential representation

Size: px

Start display at page:

Download "Pointers. Array. Solution to the data movement in sequential representation"

Berenice Dean
5 years ago
Views:

1 1 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 2

3 Pointers For any type T in C, there is corresponding type pointerto-t Actual value of pointer type : an address of memory Pointer operators in C the address operator : & the dereferencing(or indirection) operator : * 3

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); 4

5 Singly Linked Lists Composed 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 ptr bat cat sat vat NULL 5

6 Singly Linked Lists To insert mat between cat and sat ptr bat cat sat vat NULL mat 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 Caution) step 3 must be done before step 4 6

7 Singly Linked Lists To delete mat from the list ptr bat cat mat sat vat NULL 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 operations 7

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 8

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

10 Singly Linked Lists Create new nodes 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 b a t \0 NULL ptr 10

11 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; ptr NULL 11

12 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; 12

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

14 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; 14

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 15

16 Singly Linked Lists 1) the node to be deleted is the first node in the list ptr node trail = NULL ptr NULL NULL 2) otherwise (a) before deletion (b) after deletion ptr trail node ptr NULL NULL (a) before deletion (b) after deletion 16

17 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); 17

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 ); 18

19 Dynamically Linked Stacks Representing stack / queue by linked list top element link NULL (a) linked stack front rear element link NULL (b) linked queue 19

20 Dynamically Linked Stacks Representing N stacks by linked lists #define MAX_STACKS 10 /* N=MAX_STACKS=10 */ typedef struct { int key; /* other fields */ element; typedef struct stack *stack_ptr; typedef struct stack { element item; stack_ptr link; ; stack_ptr top[max_stacks]; 20

21 Dynamically Linked Stacks top[0] element link key NULL top[1] NULL top[max_stacks-1] NULL 21

22 Dynamically Linked Stacks Initial condition for stacks top[i] = NULL, 0 i < MAX_STAKCS Boundary condition for n stacks Empty condition: top[i] = NULL iff the i-th stack is empty Full condition: IS_FULL(temp) iff the memory is full 22

23 Dynamically Linked Stacks 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; 23

24 Dynamically Linked Stacks 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; 24

25 Dynamically Linked Queues Representing M queues by linked lists #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]; 25

26 Dynamically Linked Queues front[0] rear[0] element link key NULL front[1] rear[1] NULL front[max_queues-1] rear[max_queues-1] NULL 26

27 Dynamically Linked Queues Initial conditon for queues front[i]=null,0 i < MAX_QUEUES Boundary condition for queues Empty condition: front[i]= NULL iff the i-th queue is empty Full condition: IS_FULL(temp) iff the memory is full 27

28 Dynamically Linked 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; 28

29 Dynamically Linked 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; 29

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 30

31 Polynomials Representing polynomials as singly linked lists A(x) = a m-1 x e m a 0 x e 0 typedef struct poly_node *poly_ptr; typedef struct poly_node { int coef; int expon; poly_ptr link; ; poly_ptr a,b,d; 31

32 Polynomials poly_node a = 3x x a coef expon link NULL b = 8x 14-3x x 6 b NULL 32

33 Polynomials Adding polynomials NULL a NULL b NULL d rear (a) a->expon == b->expon 33

34 Polynomials NULL a NULL b NULL d rear (b) a->expon < b->expon 34

35 Polynomials NULL a NULL b NULL d (c) a->expon > b->expon rear 35

36 Polynomials NULL NULL a b d 10 6 NULL rear (d) a->expon < b->expon 36

37 Polynomials NULL NULL a b d NULL (e) b == NULL; rear 37

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) 38

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) 39

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; 40

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; 41

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

43 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) 43

44 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 NULL initial available space list 44

45 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; 45

46 Polynomials Deallocating nodes void ret_node(poly_ptr ptr) { ptr->link = avail; avail = ptr; void erase(poly_ptr *pptr) { poly_ptr temp; while (*pptr) { temp = *pptr; *pptr = (*pptr)->link; ret_node(temp); 46

47 Polynomials 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? 47

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

49 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 on the number of nodes in a list: O(1) 49

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

51 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; 51

52 Operations for Chains Inverting a chain 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) 52

53 Operations for Chains middle lead NULL NULL trail middle lead NULL NULL 53 trail middle lead

54 Operations for Chains NULL NULL trail middle lead NULL NULL trail middle lead NULL NULL 54 trail middle lead

55 Operations for Chains Concatenate 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; 55

56 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; 56

57 Operations for Chains Insert a new node at the front or at the rear of the chain ptr x1 x2 x3 NULL move down the entire length of ptr to insert rear: front-insert : O(1) rear-insert : O(n) 57

58 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; 58

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

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

61 Operations for Circularly Linked Lists Insert a new node at the rear of a circular list void insert_rear(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 front-insert, remove this line */ 61

62 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; 62

63 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 because finding the previous node is hard Doubly linked circular list doubly lists + circular lists allow two links two way direction 63

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

65 Doubly linked lists Introduce dummy node, called, head to represent empty list make easy to implement operations contains no information in item field empty doubly linked circular list with head node ptr 65

66 Doubly linked lists head node llink item rlink doubly linked circular list with head node 66

67 Doubly linked lists Insertion into a doubly linked circular list void dinsert(node_ptr node,node_ptr newnode) { /* insert newnode to the right of node */ newnode->llink = node; newnode->rlink = node->rlink; node->rlink->llink = newnode; node->rlink = newnode; time: O(1) 67

68 Doubly linked lists node node newnode insertion into an empty doubly linked circular list 68

69 Doubly linked lists Deletion from a doubly linked circular list void ddelete(node_ptr node,node_ptr deleted) { /* delete from the doubly linked list */ if (node == deleted) else { printf( Deletion of head node not permitted.\n ); deleted->llink->rlink = deleted->rlink; deleted->rlink->llink = deleted->llink; free(deleted); time complexity : O(1) 69

70 Doubly linked lists node node deleted deletion in a doubly linked list with a single node 70

71 Doubly linked lists Doubly linked circular list don t have to traverse a list : O(1) insert(delete) front/middle/rear is all the same 71

Chapter 4. LISTS. 1. Pointers

Chapter 4. LISTS. 1. Pointers Chap 4: LIST (Page 1) Chapter 4. LISTS TABLE OF CONTENTS 1. POINTERS 2. SINGLY LINKED LISTS 3. DYNAMICALLY LINKED STACKS AND QUEUES 4. POLYNOMIALS 5. ADDITIONAL LIST OPERATIONS 6. EQUIVALENCE RELATIONS