 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

 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 : *

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

 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 batsatcatvat NULL ptr

 To insert “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 Caution) step 3 must be done before step 4 batsatcatvat NULL ptr mat

 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 operations batsatcatvat NULL ptr mat

 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

 [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;

◦ 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; bat\0NULL ptr address of first node ptr->dataptr->link

 [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; 1020 NULL ptr

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

 [list insertion] ◦ Determine if we have used all available memory: IS_FULL 1020 NULL ptr node 50 temp

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

 [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

1) the node to be deleted is the first node in the list 2) otherwise 1050 ptr 20 NULL trail 10 ptr 20 NULL node (b) after deletion(a) before deletion 1050 ptr 20 NULL node 50 ptr 20 NULL trail = NULL (b) after deletion(a) before deletion

void delete(list_ptr *pptr, list_ptr trail, list_ptr node) { if(trail) trail->link = node->link; else *pptr = (*pptr)->link; free(node); }

 [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”); }

 Representing stack / queue by linked list NULL top element link ······ NULL front element link ······ rear (a) linked stack (b) linked queue

 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];

······ NULL top[0] element link ······key NULL top[1] ······ NULL top[MAX_STACKS-1] ······

◦ 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

◦ 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; }

◦ 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; }

 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];

NULL front[0] element link ······ rear[0] key NULL front[1] ······ rear[1] NULL front[MAX_QUEUES-1] ······ rear[MAX_QUEUES-1] ······

◦ 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

 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; }

 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; }

 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

 Representing polynomials as singly linked lists ◦ A(x) = a m-1 x e m-1 + ··· + 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;

◦ poly_node ◦ a = 3x x ◦ b = 8x x x 6 coefexponlink NULL a NULL b

◦ Adding polynomials (a) a->expon == b->expon NULL NULL ba 1114 NULL drear

(b) a->expon expon NULL NULL b a -310 NULL d 1114 rear

(c) a->expon > b->expon NULL NULL ba 28 rear d

(d) a->expon expon NULL NULL ba NULL rear d

(e) b == NULL; NULL NULL ba rear NULL d

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)

while(a && b) switch(COMPARE(a->expon,b->expon)) { case -1: /* a->expon 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)

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

 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; }

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

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

 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 NULL avail······ 12n initial available space list storage pool

 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; }

 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); }

 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 ?

 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

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

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

 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; };

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

NULL leadmiddletrail NULL leadtrailmiddle NULL lead NULL middle

NULL leadmiddletrail NULL leadmiddletrail NULL leadmiddletrail NULL

 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; }

 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  move down the entire length of ptr to insert rear: ◦ front-insert : O(1) ◦ rear-insert : O(n) ptrx1x2x3 NULL

 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; }

◦ (singly) circularly linked lists ◦ 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) ptr x1x2x3

◦ 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) ptrx1x2x3

 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 */ }

 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; }

◦ 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

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

◦ 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

doubly linked circular list with head node head node llinkitemrlink

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

insertion into an empty doubly linked circular list newnode node

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

deletion in a doubly linked list with a single node deleted node

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