Download - Chapter #4: LISTS
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
Transparency No. 1-3
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-4
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-5
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-6
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-7
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-8
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-9
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-10
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-11
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-12
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-13
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-14
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-15
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-16
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-17
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-18
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-19
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-20
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-21
Keimyung University, Dept. of Information & Communication
Dynamically Linked Stacks And Queues
·
·
·
NULL
top[0]
element link
······key
NULL
top[1]
······
NULL
top[MAX_STACKS-1]
······
Data Structure
Transparency No. 1-22
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-23
Keimyung University, Dept. of Information & Communication
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;
}
Data Structure
Transparency No. 1-24
Keimyung University, Dept. of Information & Communication
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;
}
Data Structure
Transparency No. 1-25
Keimyung University, Dept. of Information & Communication
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];
Data Structure
Transparency No. 1-26
Keimyung University, Dept. of Information & Communication
Dynamically Linked Stacks And Queues
NULL
front[0]
element link
······
rear[0]
key
NULL
front[1]
······
rear[1]
NULL
front[MAX_QUEUES-1]
······
rear[MAX_QUEUES-1]
·
·
·
Data Structure
Transparency No. 1-27
Keimyung University, Dept. of Information & Communication
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
Data Structure
Transparency No. 1-28
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-29
Keimyung University, Dept. of Information & Communication
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;
}
Data Structure
Transparency No. 1-30
Keimyung University, Dept. of Information & Communication
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
Data Structure
Transparency No. 1-31
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-32
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-33
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-34
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-35
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-36
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-37
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-38
Keimyung University, Dept. of Information & Communication
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)
Data Structure
Transparency No. 1-39
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-40
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-41
Keimyung University, Dept. of Information & Communication
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;
}
Data Structure
Transparency No. 1-42
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-43
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-44
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-45
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-46
Keimyung University, Dept. of Information & Communication
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;
}
Data Structure
Transparency No. 1-47
Keimyung University, Dept. of Information & Communication
Polynomials
Deallocating nodes
void ret_node(poly_ptr ptr) {
ptr->link = avail;
avail = ptr;
}
Data Structure
Transparency No. 1-48
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-49
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-50
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-51
Keimyung University, Dept. of Information & Communication
Polynomials
circular list with head nodes
- handle zero polynomials in the same
way as nonzero polynomials
ptrhead node
- -
ptrhead node
- -(empty list)
Data Structure
Transparency No. 1-52
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-53
Keimyung University, Dept. of Information & Communication
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)
Data Structure
Transparency No. 1-54
Keimyung University, Dept. of Information & Communication
Operations for Chains
NULL
leadmiddletrail
NULL
leadtrail middle
NULL
lead NULL
middle
Data Structure
Transparency No. 1-55
Keimyung University, Dept. of Information & Communication
Operations for Chains
NULL
leadmiddletrail
NULL
NULL
leadmiddletrail
NULL
NULL
leadmiddletrail
NULL
Data Structure
Transparency No. 1-56
Keimyung University, Dept. of Information & Communication
Operations for Chains
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
Transparency No. 1-57
Keimyung University, Dept. of Information & Communication
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;
}
Data Structure
Transparency No. 1-58
Keimyung University, Dept. of Information & Communication
Operations for Chains
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
Transparency No. 1-59
Keimyung University, Dept. of Information & Communication
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;
}
}
Data Structure
Transparency No. 1-60
Keimyung University, Dept. of Information & Communication
Operations for Chains
Insert a new node at the front of a list(chain)
void insert_front(list_ptr *pptr, list_ptr node) {
node->link = *pptr;
*pptr = node;
}
Insert a new node at the rear of a list(chain)
- exercise
Data Structure
Transparency No. 1-61
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-62
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-63
Keimyung University, Dept. of Information & Communication
Operations forCircularly Linked Lists
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 */
}
}
Data Structure
Transparency No. 1-64
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-65
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-66
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-67
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-68
Keimyung University, Dept. of Information & Communication
Doubly linked lists
doubly linked circular list with
head node
head node
llink item rlink
Data Structure
Transparency No. 1-69
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-70
Keimyung University, Dept. of Information & Communication
Doubly linked lists
insertion into an empty doubly
linked circular list
newnode
node node
Data Structure
Transparency No. 1-71
Keimyung University, Dept. of Information & Communication
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
Transparency No. 1-72
Keimyung University, Dept. of Information & Communication
Doubly linked lists
deletion in a doubly linked list
with a single node
deleted
node
node