Copyright 2000-2009 Networking Laboratory Chapter 4. LISTS Horowitz, Sahni, and Anderson-Freed...

Copyright 2000-2009 Networking Laboratory

Chapter 4. Chapter 4. LISTS LISTS

Horowitz, Sahni, and Anderson-FreedFundamentals of Data Structures in C, 2nd Edition

Computer Science Press, 2008

Fall 2009 Course, Sungkyunkwan University

Hyunseung [email protected]

Fall 2009 Data Structures

Singly Linked ListsSingly 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

Networking Laboratory 2/57

bat satcat vat NULL

ptr



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


bat satcat vat 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 operation


bat satcat vat NULL

ptr

mat



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;




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;


b a t \0 NULL

ptr

address of

first nodeptr->data ptr->link



Ex 4.2 [two-node linked list] create a linked list of integers



int data;

list_ptr link;

};

list_ptr ptr = NULL;

10 20 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;

}




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


10 20 NULL

ptr

node 50

temp


Singly Linked ListsSingly Linked Listsvoid 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;

}

}




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


10 50

ptr

20 NULL

node

50

ptr

20 NULL

trail = NULL

(b) after deletion(a) before deletion

10 50

ptr

20 NULL

trail

10

ptr

20 NULL

node

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

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

}



Dynamically Linked Stacks And QueuesDynamically 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];

NULL

top

element link

······

NULL

front

element link

······

rear(a) linked stack

(b) linked queue




·

·

·

NULL

top[0]

element link

······key

NULL

top[MAX_STACKS-1]

······

initial condition for n stackstop[i] = NULL, 0 ≤ i < MAX_STACKS

boundary conditionstop[i]==NULL iff the ith stack is emptyIS_FULL(temp) iff the memory is full




Add to a linked stackvoid 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);




Delete from a linked stackelement 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]);




#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

element link

······

rear

(b) linked queue




NULL

front[0]

element link

······

rear[0]

key

NULL

front[MAX_QUEUES-1]

······

rear[MAX_QUEUES-1]·

·

·

initial conditon for n queues

front[i]=NULL, 0 £ i < MAX_QUEUES

boundary conditionsfront[i]==NULL iff the ith queue is emptyIS_FULL(temp) iff the memory is full




Add to the rear of a linked queuevoid 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);




Delete from the front of a linked queueelement 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



PolynomialsPolynomials

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


coef expon link

3 14 2 8 1 0 NULL

a

8 14 -3 10 10 6 NULL

b



Adding polynomials

(a) a->expon == b->expon


3 14 2 8 1 0 NULL

8 14 -3 10 10 6 NULL

b

a

11 14 NULL

d rear



(b) a->expon < b->expon


3 14 2 8 1 0 NULL

8 14 -3 10 10 6 NULL

b

a

-3 10 NULL

d

11 14

rear



(c) a->expon > b->expon


3 14 2 8 1 0 NULL

8 14 -3 10 10 6 NULL

b

a

2 8 NULL

rear

11 14 -3 10

d



(d) a->expon < b->expon


3 14 2 8 1 0 NULL

8 14 -3 10 10 6 NULL

b

a

2 811 14 -3 10

10 6 NULL

rear

d



(e) b == NULL;

3 14 2 8 1 0 NULL

8 14 -3 10 10 6 NULL

b

a

2 811 14 -3 10

rear

10 6 1 0 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)) {


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;

}




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

}




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


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 free nodes


NULLavail

initial available space list

······

1 2 n

storage pool



Allocating nodespoly_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)) {


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



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)




Circular list with head nodes

handle zero polynomials in the same way as nonzero polynomials

ptrhead node

- -

ptrhead node

- -(empty list)



Operations for ChainsOperations for Chains

Inverting (or reversing) a chain “in place” by using three pointers lead, middle, trail



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)




NULL

leadmiddletrail

NULL

leadtrail middle

NULL

lead NULL

middle




NULL

leadmiddletrail

NULL

NULL

leadmiddletrail

NULL

NULL

leadmiddletrail

NULL




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;

}

}




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


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

}

}



Operations for Circularly Linked ListsOperations 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)


ptr x1 x2 x3



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)


ptrx1 x2 x3



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

}

}




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;

}



Doubly linked listsDoubly 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




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

llink item rlink



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

node



Doubly linked circular list

don’t have to traverse a list : O(1)

insert(delete) front/middle/rear is all the same


Copyright 2000-2009 Networking Laboratory Chapter 4. LISTS Horowitz, Sahni, and Anderson-Freed...

Documents

Transcript of Copyright 2000-2009 Networking Laboratory Chapter 4. LISTS Horowitz, Sahni, and Anderson-Freed...