Chapter #4: LISTS

Data Structure, 2003 Spring

Chapter #4: Chapter #4: LISTSLISTS

Data Structure

Transparency No. 1-2

Keimyung University, Dept. of Information & Communication

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

Data Structure



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

Data Structure



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

Data Structure



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

bat satcat vat NULL

ptr

Data Structure



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

bat satcat vat NULL

ptr

mat

Data Structure



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

bat satcat vat NULL

ptr

mat

Data Structure



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

Data Structure



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;

Data Structure



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;

b a t \0 NULL

ptr

address of

first nodeptr->data ptr->link

Data Structure



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;

}

10 NULL

ptr

ptr->data ptr->link

first.data first.link

Data Structure



Singly Linked Listsmain()

{

list_node first = { 10, NULL};

list_ptr ptr = &first;

list_node second = { 20, NULL};

first.link = &second;

}

10 20 NULL

ptrfirst second

Data Structure



Singly Linked Lists

Ex 4.3 [list insertion]

determine if we have used all available memory: IS_FULL

10 20 NULL

ptr

node 50

temp

10 20 NULL

ptr

Data Structure



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;

}

Data Structure



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

Data Structure



Singly Linked Lists

1) the node to be deleted is the

first node in the list

2) otherwise

10 50

ptr

20 NULL

trail

10

ptr

20 NULL

node

(b) after deletion(a) before deletion

10 50

ptr

20 NULL

node

50

ptr

20 NULL

trail = NULL

(b) after deletion(a) before deletion

Data Structure



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

Data Structure



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

}

Data Structure



Dynamically Linked stacks And Queues

representing stack / queue by linked list

NULL

top

element link

······

NULL

front

element link

······

rear

(a) linked stack

(b) linked queue

Data Structure



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

Data Structure




·

·

·

NULL

top[0]

element link

······key

NULL

top[1]

······

NULL

top[MAX_STACKS-1]

······

Data Structure



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

Data Structure




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;

}

Data Structure




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;

}

Data Structure




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

Data Structure




NULL

front[0]

element link

······

rear[0]

key

NULL

front[1]

······

rear[1]

NULL

front[MAX_QUEUES-1]

······

rear[MAX_QUEUES-1]

·

·

·

Data Structure




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

Data Structure



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;

}

Data Structure




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;

}

Data Structure




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

Data Structure



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;

Data Structure



Polynomials

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

Data Structure



Polynomials

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

Data Structure



Polynomials

(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

Data Structure



Polynomials

(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

Data Structure



Polynomials

(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

Data Structure



Polynomials

(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

Data Structure



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


exit(1);

}

front = rear;

(to be continued)

Data Structure



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)

Data Structure



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;

}

Data Structure



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


exit(1);

}

temp->coef = coe;

temp->expon = exp;

(*pptr)->link = temp;

*pptr=temp;

}

Data Structure



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)

Data Structure



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

Data Structure



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)

Data Structure



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

NULLavail

initial available space list

······

1 2 n

storage pool

Data Structure



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


exit(1);

}

}

return node;

}

Data Structure



Polynomials

Deallocating nodes

void ret_node(poly_ptr ptr) {

ptr->link = avail;

avail = ptr;

}

Data Structure



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 ?

Data Structure



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

Data Structure



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)

Data Structure



Polynomials

circular list with head nodes

- handle zero polynomials in the same

way as nonzero polynomials

ptrhead node

- -

ptrhead node

- -(empty list)

Data Structure



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;

};

Data Structure




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)

Data Structure




NULL

leadmiddletrail

NULL

leadtrail middle

NULL

lead NULL

middle

Data Structure




NULL

leadmiddletrail

NULL

NULL

leadmiddletrail

NULL

NULL

leadmiddletrail

NULL

Data Structure




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;

}

}

Data Structure




finding the length of a list(chain)

int length(list_ptr ptr) {

int count = 0;

while (ptr) {

count++;

ptr = ptr->link;

}

return count;

}

Data Structure




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)

ptr x1 x2 x3 NULL

Data Structure




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;

}

}

Data Structure




Insert a new node at the front of a list(chain)


node->link = *pptr;

*pptr = node;

}

Insert a new node at the rear of a list(chain)

- exercise

Data Structure



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 both front and rear:

insert-front : O(n)

insert-rear : O(n)

ptr x1 x2 x3

Data Structure



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)

ptrx1 x2 x3

Data Structure



Operations forCircularly Linked Lists

Insert a new node at the front of a circular list


if (IS_EMPTY(*pptr)) {

*pptr = node;

node->link = node;

}

else {

node->link = (*pptr)->link;

(*pptr)->link = node;

*pptr = node; /* for rear-insert */

}

}

Data Structure



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;

}

Data Structure



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 list

- doubly lists + circular lists

- allow two links

- two way direction

Data Structure



Doubly linked liststypedef struct Node {

struct Node *llink;

element item;

struct Node *rlink;

} node;

typedef struct Node *node_ptr; // typedef node *node_ptr;

suppose that ptr points to any node in a doubly linked list

ptr = ptr->llink->rlink = ptr->rlink->llink

Data Structure



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

Data Structure



Doubly linked lists

doubly linked circular list with

head node

head node

llink item rlink

Data Structure



Doubly linked listsinsertion into a doubly linked circular list

main(){ node head; node_ptr ptr, temp; ptr =head.rlink = head.llink = &head; temp = (node_ptr) malloc(sizeof(node)); dinsert ( ptr, temp);}

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)

Data Structure



Doubly linked lists

insertion into an empty doubly

linked circular list

newnode

node node

Data Structure



Doubly linked listsdeletion from a doubly linked circular listmain(){ node head; node_ptr ptr, temp; ptr =head.rlink = head.llink = &head; temp = (node_ptr) malloc(sizeof(node)); dinsert ( ptr, temp); ddelete ( ptr, temp); free(temp);}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)

Data Structure



Doubly linked lists

deletion in a doubly linked list

with a single node

deleted

node

node

Data Structure



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

Chapter #4: LISTS

Documents

Transcript of Chapter #4: LISTS