133.l3-more list (class)

7/31/2019 133.L3-More List (Class)

1/24

CSE 133

Data Structures

Mohammad Nazmul Haque

Lecturer, Dept. of CSE

More on lists. Circular lists. Doubly linked lists.


2/24

Applications of Linked Lists

Stacks and Queues Implemented with LinkedLists

Polynomials Implemented with Linked Lists

Remember the array based implementation? Hint: two strategies, one efficient in terms of space, one

in terms of running time


3/24

Operations on Linked Lists

Running time?

insert, remove

traverse, swap

How to reverse the elements of a list?


4/24

typedef struct poly_node *poly_pointer;typedef struct poly_node {int coef;int expon;poly_pointer next;

};

poly_pointer a, b, c;

A x a x a x a xm

e

m

e em m( ) ...= + + +

1 2 0

1 2 0

coef expon link

Representation

Polynomials


5/24

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

Example


6/24

3 14 2 8

1 0a

8 14 -3 10 10 6

b

11 14

d

a->expon == b->expon

3 14 2 8

1 0a

8 14 -3 10 10 6

b11 14

d

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

Adding Polynomials


7/24

3 14 2 8 1 0

a

8 14 -3 10 10 6b

11 14

a->expon > b->expon

-3 10

d

2 8

Adding Polynomials (contd)


8/24

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

Adding Polynomials (contd)


9/24

case -1: /* a->expon < b->expon */attach(b->coef, b->expon, &rear);b= b->next;break;

case 0: /* a->expon == b->expon */

sum = a->coef + b->coef;if (sum) attach(sum,a->expon,&rear);a = a->next; b = b->next;break;

case 1: /* a->expon > b->expon */attach(a->coef, a->expon, &rear);a = a->next;

}}for (; a; a = a->next)

attach(a->coef, a->expon, &rear);for (; b; b=b->next)

attach(b->coef, b->expon, &rear);rear->next = NULL;temp = front; front = front->next; free(temp);

return front;}


10/24

(1) coefficient additions

0 additions min(m, n)

where m (n) denotes the number of terms in A (B).

(2) exponent comparisonsextreme case

em-1 > fm-1 > em-2 > fm-2 > > e0 > f0m+n-1 comparisons

(3) creation of new nodesextreme case

m + n new nodes

summary O(m+n)

Analysis


11/24

void 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)->next = temp;*ptr = temp;

}

Attach a Term


12/24

Other types of lists:

Circular lists

Doubly linked lists


13/24

3 14 2 8 1 0ptr

ptr

avail...

avail

temp

circular list vs. chain

Circularly linked lists


14/24

X1 X2 X3 a

What happens when we insert a node to the front of a circular

linked list?

Problem: move down the whole list.

Operations in a circular list

X1 X2 X3 a

Keep a pointer points to the last node.

A possible solution:


15/24

void insertFront (pnode* ptr, pnode node){

/* insert a node in the list with head

(*ptr)->next */if (IS_EMPTY(*ptr)) {*ptr= node;node->next = node; /* circular link */

}else {

node->next = (*ptr)->next; (1)(*ptr)->next = node; (2)}

}

X1 X2 X3

(1)

(2) ptr

Insertion


16/24

int length(pnode ptr){

pnode temp;int count = 0;

if (ptr) {temp = ptr;do {

count++;temp = temp->next;

} while (temp!=ptr);}

return count;}

List length


17/24

Doubly Linked List

Keep a pointer to the next and the previouselement in the list

typedef struct node *pnode;typedef struct node {

char data [4];pnode next;

pnode prev;}


18/24

Doubly Linked List

Keep a header and trailer pointers (sentinels)with no content

header.prev = null; header.next = first element

trailer.next = null; trailer.prev = last element

Update pointers for every operation performed

on the listHow to remove an element from the tail of thelist ?


19/24

Doubly Linked List

removeLast()

Runningtime?

How doesthis compareto simplylinked lists?


20/24

Doubly Linked List

insertFirst

swapElements


21/24

15000

0040

00012

01100

Previous scheme:

represent each non-NULL element as a tuple(row, column, value)

New scheme:

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

Revisit Sparse Matrices


22/24

down right

value

row col

aij

i j

entry node

aij

Nodes in the Sparse Matrix


23/24

4 4

1 012

2 1-4

0 211

3 3-15

1 15

Circular linked list

Linked Representation


24/24

#define MAX_SIZE 50 /* size of largest matrix */typedef struct mnode *pmnode;

typedef struct mnode {int row;int col;int value;

pmnode next, down;

};

Operations on sparse matrices

Sparse Matrix Implementation

133.l3-more list (class)

Documents