CHAPTER 4 1

CHAPTER 4

LISTS

All the programs in this file are selected fromEllis Horowitz, Sartaj Sahni, and Susan Anderson-Freed“Fundamentals of Data Structures in C”,Computer Science Press, 1992.

CHAPTER 4 2

Introduction

Arraysuccessive items locate a fixed distance

disadvantage– data movements during insertion and deletion– waste space in storing n ordered lists of varying

size possible solution

– linked list

CHAPTER 4 3

4.1.1 Pointer Can Be Dangerous

pointer

int i, *pi;

pi = &i; i=10 or *pi=10

pi= malloc(size of(int));

/* assign to pi a pointer to int */

pf=(float *) pi;

/* casts an int pointer to a float pointer */

CHAPTER 4 4

4.1.2 Using Dynamically Allocated Storage

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

*Program4.1:Allocation and deallocation of pointers (p.138)

request memory

return memory

CHAPTER 4 5

4.2 SINGLY LINKED LISTS

bat cat sat vat NULL

*Figure 4.1: Usual way to draw a linked list (p.139)

CHAPTER 4 6

bat cat sat vat NULL

*Figure 4.2: Insert mat after cat (p.140)

mat

Insertion

CHAPTER 4 7

bat cat sat vat NULL mat

*Figure 4.3: Delete mat from list (p.140)

danglingreference

CHAPTER 4 8

typedef struct list_node, *list_pointer;typedef struct list_node { char data [4]; list_pointer link; };Creationlist_pointer ptr =NULL; Testing#define IS_EMPTY(ptr) (!(ptr))Allocationptr=(list_pointer) malloc (sizeof(list_node));

Example 4.1: create a linked list of words

Declaration

CHAPTER 4 9

b a t \0 NULL

address offirst node

ptr data ptr link

ptr

*Figure 4.4:Referencing the fields of a node(p.142)

e -> name (*e).namestrcpy(ptr -> data, “bat”);ptr -> link = NULL;

CHAPTER 4 10

typedef struct list_node *list_pointer;typedef struct list_node { int data; list_pointer link; };list_pointer ptr =NULL

Example 4.2: (p.142)

Example: create a two-node list

10 20 NULL

ptr

CHAPTER 4 11

list_pointer create2( ){/* create a linked list with two nodes */ list_pointer first, second; first = (list_pointer) malloc(sizeof(list_node)); second = ( list_pointer) malloc(sizeof(list_node)); second -> link = NULL; second -> data = 20; first -> data = 10; first ->link = second; return first;} *Program 4.2:Create a tow-node list (p.143)

10 20 NULL

ptr

CHAPTER 4 12

Pointer Review (1)

int i, *pi;

i pi1000 2000

? ?

pi = &i;

ipi

1000 2000? 1000*pi

i = 10 or *pi = 10

ipi

1000 200010 1000*pi

CHAPTER 4 13

Pointer Review (2)

typedef struct list_node *list_pointer;typedef struct list_node { int data; list_pointer link; }list_pointer ptr = NULL;

ptr1000

NULL

ptr = malloc(sizeof(list_node));

ptr10002000

2000 *ptr

ptr->data(*ptr).data

data link

CHAPTER 4 14

Pointer Review (3)

void delete(list_pointer *ptr, list_pointer trail, list_pinter node)

ptr: a pointer point to a pointer point to a list node10002000ptr

20003000

3000

*ptr (*ptr)->link

trail (node): a pointer point to a list node

trail10003000

3000 *trail

data link

trail->link(*trail).link

CHAPTER 4 15

Pointer Review (4)

element delete(stack_pointer *top)top

delete(&st) vs. delete(st)200 300

300

400

.

.

.

200 300top st 200

400

300 300st top

400Does not change.

CHAPTER 4 16

void insert(list_pointer *ptr, list_pointer node){/* insert a new node with data = 50 into the list ptr after node */ list_pointer temp; temp = (list_pointer) malloc(sizeof(list_node)); if (IS_FULL(temp)){ fprintf(stderr, “The memory is full\n”); exit (1); }

List Insertion:

Insert a node after a specific node

CHAPTER 4 17

temp->data = 50; if (*ptr) { noempty list temp->link =node ->link; node->link = temp; } else { empty list temp->link = NULL; *ptr =temp; }}

*Program 4.3:Simple insert into front of list (p.144)

50

10 20 NULL

temp

ptr

node

CHAPTER 4 18

10 20 NULL 50 20 NULL 50

ptr node trail = NULL ptr

(a) before deletion (b)after deletion

*Figure 4.7: List after the function call Delete(&ptr,NULL.ptr);(p.145)

CHAPTER 4 19

10 20 NULL 50 20 NULL 50

(a) before deletion (b)after deletion

Delete node other than the first node.

ptr trail node ptr

List Deletion

Delete the first node.

10 20 NULL 50 20 NULL 10

ptr trail node ptr

CHAPTER 4 20

void delete(list_pointer *ptr, list_pointer trail, list_pointer node){/* delete node from the list, trail is the preceding node ptr is the head of the list */ if (trail) trail->link = node->link; else *ptr = (*ptr) ->link; free(node);}

10 20 NULL 50

20 NULL 10

trail node

10 20 NULL 50 20 NULL50

ptr node ptr

CHAPTER 4 21

void print_list(list_pointer ptr){ printf(“The list ocntains: “); for ( ; ptr; ptr = ptr->link) printf(“%4d”, ptr->data); printf(“\n”); }

*Program 4.5: Printing a list (p.146)

Print out a list (traverse a list)

CHAPTER 4 22

4.3 DYNAMICALLY LINKED STACKS AND QUEUES

NULL

topelement link

(a) Linked Stack

NULL

frontelement link

(b) Linked queue

rear

*Figure 4.10: Linked Stack and queue (p.147)

CHAPTER 4 23

#define MAX_STACKS 10 /* maximum number of stacks */typedef struct { int key; /* other fields */ } element;typedef struct stack *stack_pointer;typedef struct stack { element item; stack_pointer link; };stack_pointer top[MAX_STACKS];

Represent n stacks

CHAPTER 4 24

#define MAX_QUEUES 10 /* maximum number of queues */typedef struct queue *queue_pointer;typedef struct queue { element item; queue_pointer link; };queue_pointer front[MAX_QUEUE], rear[MAX_QUEUES];

Represent n queues

CHAPTER 4 25

void add(stack_pointer *top, element item){ /* add an element to the top of the stack */ stack_pointer temp = (stack_pointer) malloc (sizeof (stack)); if (IS_FULL(temp)) { fprintf(stderr, “ The memory is full\n”); exit(1); } temp->item = item; temp->link = *top; *top= temp; *Program 4.6:Add to a linked stack (p.149)

}

Push in the linked stack

CHAPTER 4 26

element delete(stack_pointer *top) {/* delete an element from the stack */ stack_pointer temp = *top; element item; if (IS_EMPTY(temp)) { fprintf(stderr, “The stack is empty\n”); exit(1); } item = temp->item; *top = temp->link; free(temp); return item;}*Program 4.7: Delete from a linked stack (p.149)

pop from the linked stack

CHAPTER 4 27

enqueue in the linked queue

void addq(queue_pointer *front, queue_pointer *rear, element item)

{ /* add an element to the rear of the queue */ queue_pointer temp = (queue_pointer) malloc(sizeof (queue)); if (IS_FULL(temp)) { fprintf(stderr, “ The memory is full\n”); exit(1); } temp->item = item; temp->link = NULL; if (*front) (*rear) -> link = temp; else *front = temp; *rear = temp; }

CHAPTER 4 28

dequeue from the linked queue (similar to push)

element deleteq(queue_pointer *front) {/* delete an element from the queue */ queue_pointer temp = *front; element item; if (IS_EMPTY(*front)) { fprintf(stderr, “The queue is empty\n”); exit(1); } item = temp->item; *front = temp->link; free(temp); return item;}

CHAPTER 4 29

Polynomials

typedef struct poly_node *poly_pointer; typedef struct poly_node { int coef; int expon; poly_pointer link; }; poly_pointer a, b, c;

A x a x a x a xm

e

m

e em m( ) ...

1 2 01 2 0

coef expon link

Representation

CHAPTER 4 30

Examples

3 14 2 8 1 0a

8 14 -3 10 10 6b

a x x 3 2 114 8

b x x x 8 3 1014 10 6

null

null

CHAPTER 4 31

Adding Polynomials

3 14 2 8 1 0a

8 14 -3 10 10 6b

11 14d

a->expon == b->expon

3 14 2 8 1 0a

8 14 -3 10 10 6b

11 14d

a->expon < b->expon-3 10

CHAPTER 4 32

Adding Polynomials (Continued)

3 14 2 8 1 0a

8 14 -3 10 10 6b

11 14

a->expon > b->expon

-3 10d

2 8

CHAPTER 4 33

Alogrithm for Adding Polynomials

poly_pointer padd(poly_pointer a, poly_pointer b){ poly_pointer front, rear, temp; int sum; rear =(poly_pointer)malloc(sizeof(poly_node)); if (IS_FULL(rear)) { fprintf(stderr, “The memory is full\n”); exit(1); } front = rear; while (a && b) { switch (COMPARE(a->expon, b->expon)) {

CHAPTER 4 34

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

Delete extra initial node.

CHAPTER 4 35

Analysis

(1) coefficient additions0 additions min(m, n)where m (n) denotes the number of terms in A (B).

(2) exponent comparisonsextreme caseem-1 > fm-1 > em-2 > fm-2 > … > e0 > f0

m+n-1 comparisons(3) creation of new nodes

extreme casem + n new nodessummary O(m+n)

CHAPTER 4 36

Attach a Termvoid attach(float coefficient, int exponent, poly_pointer *ptr){/* create a new node attaching to the node pointed to by ptr. ptr is updated to point to this new node. */

poly_pointer temp; temp = (poly_pointer) malloc(sizeof(poly_node)); if (IS_FULL(temp)) { fprintf(stderr, “The memory is full\n”); exit(1); } temp->coef = coefficient; temp->expon = exponent; (*ptr)->link = temp; *ptr = temp;}

CHAPTER 4 37

A Suite for Polynomials

poly_pointer a, b, d, e;...a = read_poly();b = read_poly();d = read_poly();temp = pmult(a, b);e = padd(temp, d);print_poly(e);

read_poly()

print_poly()

padd()

psub()

pmult()

temp is used to hold a partial result.By returning the nodes of temp, we may use it to hold other polynomials

e(x) = a(x) * b(x) + d(x)

CHAPTER 4 38

Erase Polynomials

void earse(poly_pointer *ptr){/* erase the polynomial pointed to by ptr */

poly_pointer temp;

while (*ptr) { temp = *ptr; *ptr = (*ptr)->link; free(temp); }}

O(n)

CHAPTER 4 39

Circularly Linked Lists

3 14 2 8 1 0ptr

ptr

avail ...

avail

temp

circular list vs. chain

CHAPTER 4 40

Maintain an Available Listpoly_pointer get_node(void){ poly_pointer node; if (avail) { node = avail; avail = avail->link: } else { node = (poly_pointer)malloc(sizeof(poly_node)); if (IS_FULL(node)) { printf(stderr, “The memory is full\n”); exit(1); } } return node;}

CHAPTER 4 41

Maintain an Available List (Continued)

void ret_node(poly_pointer ptr){ ptr->link = avail; avail = ptr;}

void cerase(poly_pointer *ptr){ poly_pointer temp; if (*ptr) { temp = (*ptr)->link; (*ptr)->link = avail; avail = temp; *ptr = NULL; }}

Insert ptr to the front of this list

(1)(2)

Erase a circular list (see next page)

Independent of # of nodes in a list O(1) constant time

CHAPTER 4 42

4.4.4 Representing Polynomials As Circularly Linked Lists

avail

tempptr

NULL

avail

*Figure 4.14: Returning a circular list to the avail list (p.159)

(1)

(2)

CHAPTER 4 43

Head Node

3 14 2 8 1 0a

-1a

Zero polynomial

-1

a x x 3 2 114 8

Represent polynomial as circular list.

(1) zero

(2) others

CHAPTER 4 44

Another Padd

poly_pointer cpadd(poly_pointer a, poly_pointer b){ poly_pointer starta, d, lastd; int sum, done = FALSE; starta = a; a = a->link; b = b->link; d = get_node(); d->expon = -1; lastd = d; do { switch (COMPARE(a->expon, b->expon)) { case -1: attach(b->coef, b->expon, &lastd); b = b->link; break;

Set expon field of head node to -1.

CHAPTER 4 45

Another Padd (Continued)

case 0: if (starta == a) done = TRUE; else { sum = a->coef + b->coef; if (sum) attach(sum,a->expon,&lastd); a = a->link; b = b->link; } break; case 1: attach(a->coef,a->expon,&lastd); a = a->link; } } while (!done); lastd->link = d; return d;}

Link last node to first

CHAPTER 4 46

Additional List Operations

typedef struct list_node *list_pointer;typedef struct list_node { char data; list_pointer link;};

Invert single linked listsConcatenate two linked lists

CHAPTER 4 47

Invert Single Linked Lists

list_pointer invert(list_pointer lead){ list_pointer middle, trail; middle = NULL; while (lead) { trail = middle; middle = lead; lead = lead->link; middle->link = trail; } return middle;} 0: null

1: lead2: lead

...

Use two extra pointers: middle and trail.

CHAPTER 4 48

Concatenate Two Lists

list_pointer concatenate(list_pointer ptr1, list_pointer ptr2){ list_pointer 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; }}

O(m) where m is # of elements in the first list

CHAPTER 4 49

4.5.2 Operations For Circularly Linked List

X1 X2 X3 a

*Figure 4.16: Example circular list (p.165)

What happens when we insert a node to the front of a circularlinked list?

Problem: move down the whole list.

CHAPTER 4 50

X1 X2 X3 a

*Figure 4.17: Pointing to the last node of a circular list (p.165)

A possible solution:

Note a pointer points to the last node.

CHAPTER 4 51

Operations for Circular Linked Listsvoid insert_front (list_pointer *ptr, list_pointer node){ if (IS_EMPTY(*ptr)) { *ptr= node; node->link = node; } else { node->link = (*ptr)->link; (1) (*ptr)->link = node; (2) }}

X1 X2 X3

(1)(2) ptr

CHAPTER 4 52

Length of Linked List

int length(list_pointer ptr){ list_pointer temp; int count = 0; if (ptr) { temp = ptr; do { count++; temp = temp->link; } while (temp!=ptr); } return count;}

CHAPTER 4 53

Equivalence Relations

A relation over a set, S, is said to be an equivalence relation over S iff it is symmertric, reflexive, and transitive over S.

reflexive, x=xsymmetric, if x=y, then y=xtransitive, if x=y and y=z, then x=z

CHAPTER 4 54

Examples

0=4, 3=1, 6=10, 8=9, 7=4, 6=8, 3=5, 2=11, 11=1

three equivalent classes{0,2,4,7,11}; {1,3,5}; {6,8,9,10}

CHAPTER 4 55

A Rough Algorithm to Find Equivalence Classes

void equivalenec(){ initialize; while (there are more pairs) { read the next pair <i,j>; process this pair; } initialize the output; do { output a new equivalence class; } while (not done);}

What kinds of data structures are adopted?

Phase

1P

hase 2

CHAPTER 4 56

First Refinement

#include <stdio.h>#include <alloc.h>#define MAX_SIZE 24#define IS_FULL(ptr) (!(ptr))#define FALSE 0#define TRUE 1void equivalence(){ initialize seq to NULL and out to TRUE while (there are more pairs) { read the next pair, <i,j>; put j on the seq[i] list; put i on the seq[j] list; } for (i=0; i<n; i++) if (out[i]) { out[i]= FALSE; output this equivalence class; }}

direct equivalence

Compute indirect equivalenceusing transitivity

CHAPTER 4 57

Lists After Pairs are input

[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11]

seq

NULL

NULL

NULL

NULL NULL

NULL NULL

NULL

NULL

NULL NULL

NULL

typedef struct node *node_pointer ;typedef struct node { int data; node_pointer link;};

0 43 16 108 97 46 83 52 1111 0

11 3 5

1

7

0

3 8

10

4 6

9

8 6 0

24

11

CHAPTER 4 58

Final Version for Finding Equivalence Classes

void main(void){ short int out[MAX_SIZE]; node_pointer seq[MAX_SIZE]; node_pointer x, y, top; int i, j, n; printf(“Enter the size (<= %d) “, MAX_SIZE); scanf(“%d”, &n); for (i=0; i<n; i++) { out[i]= TRUE; seq[i]= NULL; } printf(“Enter a pair of numbers (-1 -1 to quit): “); scanf(“%d%d”, &i, &j);

Phase 1: input the equivalence pairs:

CHAPTER 4 59

while (i>=0) { x = (node_pointer) malloc(sizeof(node)); if (IS_FULL(x)) fprintf(stderr, “memory is full\n”); exit(1); } x->data= j; x->link= seq[i]; seq[i]= x; if (IS_FULL(x)) fprintf(stderr, “memory is full\n”); exit(1); } x->data= i; x->link= seq[j]; seq[j]= x; printf(“Enter a pair of numbers (-1 -1 to \ quit): “); scanf(“%d%d”, &i, &j); }

Insert x to the top of lists seq[i]

Insert x to the top of lists seq[j]

CHAPTER 4 60

for (i=0; i<n; i++) { if (out[i]) { printf(“\nNew class: %5d”, i); out[i]= FALSE; x = seq[i]; top = NULL; for (;;) { while (x) { j = x->data; if (out[j]) { printf(“%5d”, j); out[j] = FALSE; y = x->link; x->link = top; top = x; x = y; } else x = x->link; } if (!top) break; x = seq[top->data]; top = top->link; } } }

Phase 2: output the equivalence classes

push

pop

CHAPTER 4 61

15000

0040

00012

01100

4.7 Sparse Matrices

inadequates of sequential schemes(1) # of nonzero terms will vary after some matrix computation(2) matrix just represents intermediate results

new schemeEach column (row): a circular linked list with a head node

CHAPTER 4 62

Revisit Sparse Matrices

down head right

nexthead node

down entry right

value

row col

entry

aij

i j

entry node

aij

# of head nodes = max{# of rows, # of columns}

連同一列元素連同一行元

素

CHAPTER 4 63

Linked Representation for Matrix

4 4

1 012

2 1-4

0 211

3 3-15

1 15

Circular linked list

CHAPTER 4 64

#define MAX_SIZE 50 /* size of largest matrix */typedef enum {head, entry} tagfield;typedef struct matrix_node *matrix_pointer;typedef struct entry_node { int row; int col; int value; };typedef struct matrix_node { matrix_pointer down; matrix_pointer right; tagfield tag;

CHAPTER 4 65

union { matrix_pointer next; entry_node entry; } u; };matrix_pointer hdnode[MAX_SIZE];

CHAPTER 4 66

[0] [1] [2]

[0][1][2][3][4]

4 4 4 0 2 11 1 0 12 2 1 -4 3 3 -15

*Figure 4.22: Sample input for sparse matrix (p.174)

CHAPTER 4 67

Read in a Matrix

matrix_pointer mread(void){/* read in a matrix and set up its linked list. An global array hdnode is used */ int num_rows, num_cols, num_terms; int num_heads, i; int row, col, value, current_row; matrix_pointer temp, last, node;

printf(“Enter the number of rows, columns and number of nonzero terms: “);

CHAPTER 4 68

scanf(“%d%d%d”, &num_rows, &num_cols, &num_terms); num_heads = (num_cols>num_rows)? num_cols : num_rows; /* set up head node for the list of head nodes */ node = new_node(); node->tag = entry; node->u.entry.row = num_rows; node->u.entry.col = num_cols; if (!num_heads) node->right = node; else { /* initialize the head nodes */ for (i=0; i<num_heads; i++) { term= new_node(); hdnode[i] = temp; hdnode[i]->tag = head; hdnode[i]->right = temp; hdnode[i]->u.next = temp; }

O(max(n,m))

CHAPTER 4 69

current_row= 0; last= hdnode[0]; for (i=0; i<num_terms; i++) { printf(“Enter row, column and value:”); scanf(“%d%d%d”, &row, &col, &value); if (row>current_row) { last->right= hdnode[current_row]; current_row= row; last=hdnode[row]; } temp = new_node(); temp->tag=entry; temp->u.entry.row=row; temp->u.entry.col = col; temp->u.entry.value = value; last->right = temp;/*link to row list */ last= temp; /* link to column list */ hdnode[col]->u.next->down = temp; hdnode[col]=>u.next = temp; }

...

利用 next field 存放 column的 last node

CHAPTER 4 70

/*close last row */ last->right = hdnode[current_row]; /* close all column lists */ for (i=0; i<num_cols; i++) hdnode[i]->u.next->down = hdnode[i]; /* link all head nodes together */ for (i=0; i<num_heads-1; i++) hdnode[i]->u.next = hdnode[i+1]; hdnode[num_heads-1]->u.next= node; node->right = hdnode[0]; } return node;}

O(max{#_rows, #_cols}+#_terms)

CHAPTER 4 71

Write out a Matrix

void mwrite(matrix_pointer node){ /* print out the matrix in row major form */ int i; matrix_pointer temp, head = node->right; printf(“\n num_rows = %d, num_cols= %d\n”, node->u.entry.row,node->u.entry.col); printf(“The matrix by row, column, and value:\n\n”); for (i=0; i<node->u.entry.row; i++) { for (temp=head->right;temp!=head;temp=temp->right) printf(“%5d%5d%5d\n”, temp->u.entry.row, temp->u.entry.col, temp->u.entry.value); head= head->u.next; /* next row */ }}

O(#_rows+#_terms)

CHAPTER 4 72

Erase a Matrix

void merase(matrix_pointer *node){ int i, num_heads; matrix_pointer x, y, head = (*node)->right; for (i=0; i<(*node)->u.entry.row; i++) { y=head->right; while (y!=head) { x = y; y = y->right; free(x); } x= head; head= head->u.next; free(x); } y = head; while (y!=*node) { x = y; y = y->u.next; free(x); } free(*node); *node = NULL;}

Free the entry and head nodes by row.

O(#_rows+#_cols+#_terms)

Alternative: 利用 Fig 4.14的技巧，把一列資料 erase (constant time)

CHAPTER 4 73

Doubly Linked List

Move in forward and backward direction.

Singly linked list (in one direction only)How to get the preceding node during deletion or insertion?Using 2 pointers

Node in doubly linked listleft link field (llink)data field (item)right link field (rlink)

CHAPTER 4 74

Doubly Linked Lists

typedef struct node *node_pointer;typedef struct node { node_pointer llink; element item; node_pointer rlink;}

head node

llink item rlink

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

CHAPTER 4 75

ptr

*Figure 4.24:Empty doubly linked circular list with head node (p.180)

CHAPTER 4 76

node

newnode

node

*Figure 4.25: Insertion into an empty doubly linked circular list (p.181)

CHAPTER 4 77

Insert

void dinsert(node_pointer node, node_pointer newnode){ (1) newnode->llink = node; (2) newnode->rlink = node->rlink; (3) node->rlink->llink = newnode; (4) node->rlink = newnode;}

head node

llink item rlink

(2)(4)(1) (3)

CHAPTER 4 78

Delete

void ddelete(node_pointer node, node_pointer deleted){ if (node==deleted) printf(“Deletion of head node not permitted.\n”); else { (1) deleted->llink->rlink= deleted->rlink; (2) deleted->rlink->llink= deleted->llink; free(deleted); }}

head node

llink item rlink

(1)

(2)