CS201: Data Structures and Discrete Mathematics I

Linked Lists, Stacks and Queues

04/10/23 CS 201

Data Structure

• A construct that can be defined within a programming language to store a collection of data– one may store some data in an array of

integers, an array of objects, or an array of arrays

04/10/23 CS 201

Abstract Data Type (ADT)• Definition: a collection of data together

with a set of operations on that data– specifications indicate what ADT

operations do, but not how to implement them

– data structures are part of an ADT’s implementation

• Programmer can use an ADT without knowing its implementation.

04/10/23 CS 201

Typical Operations on Data

• Add data to a data collection

• Remove data from a data collection

• Ask questions about the data in a data collection. E.g., what is the value at a particular location, and is x in the collection?

04/10/23 CS 201

Why ADT

• Hide the unnecessary details• Help manage software complexity• Easier software maintenance• Functionalities are less likely to change• Localised rather than global changes

04/10/23 CS 201

Illustration

Linked Lists

04/10/23 CS 201

Lists• List: a finite sequence of data items

a1, a2, a3, …, an• Lists are pervasive in computing

– e.g. class list, list of chars, list of events• Typical operations:

– Creation– Insert / remove an element– Test for emptiness– Find an item/element– Current element / next / previous– Find k-th element– Print the entire list

04/10/23 CS 201

Array-Based List Implementation• One simple implementation is to use arrays

– A sequence of n-elements• Maximum size is anticipated a priori.• Internal variables:

– Maximum size maxSize (m)– Current size curSize (n)– Current index cur– Array of elements listArray

n

curSize

a1 a2 a3 an

listArray

unused

0 1 2 n-1 m

cur

04/10/23 CS 201

Inserting Into an Array• While retrieval is very fast, insertion and

deletion are very slow– Insert has to shift upwards to create gap

a1 a2 a7 a8a4 a5 a6a3

Step 1 : Shift upwards

8

Size arr

8 a1 a2 a3 a7 a8

Size arr

a4 a5 a6

Example : insert(2, it, arr)

Step 2 : Write into gap

it

Step 3 : Update Size

9

04/10/23 CS 201

Codingtypedef struct {

int arr[MAX];int max;int size;

} LIST

void insert(int j, int it, LIST *pl) { // pre : 1<=j<=size+1

int i;

for (i=pl->size; i>=j; i=i-1) // Step 1: Create gap

{ pl->arr[i+1]= pl->arr[i]; }; pl->arr[j]= it; // Step 2: Write to gap

pl->size = pl->size + 1; // Step 3: Update size }

04/10/23 CS 201

Deleting from an Array• Delete has to shift downwards to close gap of

deleted item

Step 1 : Close Gap

9 a1 a2 it a7a8

size

a5 a6a3a8

arr

9 a1 a2 it a7 a8

size

a4 a5 a6a3

arr

Example: deleteItem(4, arr)

Step 2 : Update Size

8

Not part of list

04/10/23 CS 201

Coding

void delete(int j, LIST *pl) { // pre : 1<=j<=sizefor (i=j+1; i<=pl->size; i=i+1)

// Step1: Close gap

{ pl->arr[i-i]=pl->arr[i]; }; // Step 2: Update

size pl->size = pl->size - 1;

}

04/10/23 CS 201

Linked List Approach• Main problem of array is the slow deletion/insertion since it

has to shift items in its contiguous memory• Solution: linked list where items need not be contiguous

with nodes of the form

• Sequence (list) of four items < a1,a2 ,a3 ,a4 > can be represented by:

item next

ai

a1 a2 a3 a4

head representsnull

Pointer-Based Linked Lists

• A node in a linked list is usually a structstruct Node{ int item Node *next;}; //end struct

• A node is dynamically allocatedNode *p;p = malloc(sizeof(Node));

A node

04/10/23 CS 201

Pointer-Based Linked Lists

• The head pointer points to the first node in a linked list

• If head is NULL, the linked list is empty– head=NULL

• head=malloc(sizeof(Node))

04/10/23 CS 201

A Sample Linked List

04/10/23 CS 201

Traverse a Linked List

• Reference a node member with the -> operatorp->item;

• A traverse operation visits each node in the linked list– A pointer variable cur keeps track of the

current nodefor (Node *cur = head; cur != NULL; cur = cur->next)

x = cur->item;04/10/23 CS 201

Traverse a Linked List

The effect of the assignment cur = cur->next

04/10/23 CS 201

Delete a Node from a Linked List

• Deleting an interior/last nodeprev->next=cur->next;

• Deleting the first nodehead=head->next;

• Return deleted node to systemcur->next = NULL;free(cur);cur=NULL;

04/10/23 CS 201

Delete a Node from a Linked List

Deleting a node from a linked list

Deleting the first node04/10/23 CS 201

Insert a Node into a Linked List

• To insert a node between two nodesnewPtr->next = cur;

prev->next = newPtr;

Inserting a new node into a linked list

CS 201

Insert a Node into a Linked List

• To insert a node at the beginning of a linked list

newPtr->next = head;head = newPtr;

Inserting at the beginning of a linked list

CS 201

Insert a Node into a Linked List

• Inserting at the end of a linked list is not a special case if cur is NULLnewPtr->next = cur;prev->next = newPtr;

Inserting at the end of a linked list

CS 201

Look up

BOOLEAN lookup (int x, Node *L)

{ if (L == NULL)

return FALSE

else if (x == L->item)

return TRUE

else

return lookup(x, L-next);

}04/10/23 CS 201

An ADT Interface for List

• Functions– isEmpty– getLength– insert– delete– Lookup– …

• Data Members– head– Size

• Local variables to member functions– cur– prev

04/10/23 CS 201

04/10/23 CS 201

Doubly Liked Lists• Frequently, we need to traverse a sequence

in BOTH directions efficiently • Solution : Use doubly-linked list where each

node has two pointers

next

forward traversal

Doubly Linked List.

x1 x4x2head

x3

backward traversal

prev

04/10/23 CS 201

Circular Linked Lists

• May need to cycle through a list repeatedly, e.g. round robin system for a shared resource

• Solution : Have the last node point to the first node

x1 x2 xn. . .

Circular Linked List.

head

Stacks

04/10/23 CS 201

What is a Stack?• A stack is a list with the restriction that

insertions and deletions can be performed in only one position, namely, the end of the list, called the top.

• The operations: push (insert) and pop (delete)pop push(o)

6

7

2

3Top

04/10/23 CS 201

Stack ADT Interface

• The main functions in the Stack ADT are (S is the stack)

boolean isEmpty(); // return true if empty

boolean isFull(S); // return true if full

void push(S, item); // insert item into stack void pop(S); // remove most recent item

void clear(S); // remove all items from stack Item top(S); // retrieve most recent item Item topAndPop(S); // return & remove most recent item

04/10/23 CS 201

Sample Operation

Stack S = malloc(sizeof(stack));

push(S, “a”);

push(S, “b”);

push(S, “c”);

d=top(S);

pop(S);

push(S, “e”);

pop(S);

s

ab

c

top

e

d

04/10/23 CS 201

Implementation by Linked Lists

• Can use a Linked List as implementation of stack

Top of Stack = Front of Linked-List

StackLL

lst

a1 a2 a3 a4

head

LinkedListItr

04/10/23 CS 201

Codestruct Node { int element; Node * next;};typedef struct Node * STACK;

04/10/23 CS 201

More code

More Code

04/10/23 CS 201

04/10/23 CS 201

Implementation by Array• use Array with a top index pointer as an implementation of stack

E F

0 1 7 8 92 3 4 5 6

A B C D

top

StackAr

arr

A

04/10/23 CS 201

Code

04/10/23 CS 201

More code

04/10/23 CS 201

More code

Effects

04/10/23 CS 201

04/10/23 CS 201

Applications

• Many application areas use stacks:– line editing– bracket matching – postfix calculation– function call stack

04/10/23 CS 201

Line Editing• A line editor would place characters read into a

buffer but may use a backspace symbol (denoted by ) to do error correction

• Refined Task – read in a line – correct the errors via backspace– print the corrected line in reverse

Input :

Corrected Input :

Reversed Output :

abc_defgh2klpqrwxyz

abc_defg2klpwxyz

zyxwplk2gfed_cba

04/10/23 CS 201

The Procedure• Initialize a new stack• For each character read:

– if it is a backspace, pop out last char entered

– if not a backspace, push the char into stack

• To print in reverse, pop out each char for output

Input : fghryz

Corrected Input :

Reversed Output :

fyz

zyf Stack

f

g

hr

y

z

04/10/23 CS 201

Bracket Matching Problem• Ensures that pairs of brackets are properly matched

• An Example: {a,(b+f[4])*3,d+f[5]}

• Bad Examples:

(..)..) // too many closing brackets

(..(..) // too many open brackets

[..(..]..) // mismatched brackets

04/10/23 CS 201

Informal ProcedureInitialize the stack to emptyFor every char read

if open bracket then push onto stackif close bracket, then

return & remove most recent item from the stack

if doesn’t match then flag errorif non-bracket, skip the char read

Example

{a,(b+f[4])*3,d+f[5]}

Stack

{

(

[

)

}

]

[ ]

04/10/23 CS 201

Postfix Calculator• Computation of arithmetic expressions can be efficiently

carried out in Postfix notation with the help of a stack.

Infix - arg1 op arg2 Prefix - op arg1 arg2 Postfix - arg1 arg2 op

(2*3)+4

2*(3+4) 2 3 4 + *

2*3+4

infix 2 3 * 4 +

postfix

04/10/23 CS 201

Informal ProcedureInitialise stack SFor each item read.

If it is an operand, push on the stackIf it is an operator,

pop arguments from stack; perform operation; push result onto the stack

2

3

4

Stack

Expr2 3 4 +

*

push(S, 2)push(S, 3)push(S, 4)

arg2=topAndPop(S)arg1=topAndPop(S)push(S, arg1+arg2)arg2=topAndPop(S)arg1=topAndPop(S)push(S, arg1*arg2)

3+4=7

2*7=14

04/10/23 CS 201

Summary• The ADT stack operations have a last-

in, first-out (LIFO) behavior• Stack has many applications

– algorithms that operate on algebraic expressions

– a strong relationship between recursion and stacks exists

• Stack can be implemented using arrays or linked lists

Queues

04/10/23 CS 201

What is a Queue?• Like stacks, queues are lists. With a queue,

however, insertion is done at one end whereas deletion is done at the other end.

• Queues implement the FIFO (first-in first-out) policy. E.g., a printer/job queue!

• Two basic operations of queues:– dequeue: remove an item/element from front– enqueue: add an item/element at the back

dequeue enqueue

04/10/23 CS 201

Queue ADT

• Queues implement the FIFO (first-in first-out) policy– An example is the printer/job queue!

enqueue(o)dequeue()

isEmpty()getFront() createQueue()

04/10/23 CS 201

Sample OperationQueue *Q;

enqueue(Q, “a”);

enqueue(Q, “b”);

enqueue(Q, “c”);

d=getFront(Q);

dequeue(Q);

enqueue(Q, “e”);

dequeue(Q);

q

front back

a b c e

d

04/10/23 CS 201

Queue ADT interface

• The main functions in the Queue ADT are (Q is the queue)

void enqueue(o, Q) // insert o to back of Q void dequeue(Q); // remove oldest item Item getFront(Q); // retrieve oldest item boolean isEmpty(Q); // checks if Q is empty boolean isFull(Q); // checks if Q is full

void clear(Q); // make Q empty }

04/10/23 CS 201

Implementation of Queue (Linked List)

• Can use LinkedListItr as underlying implementation of Queues

a1 a2 a3 a4

head tail

Queue

lst

LinkedListaddTail

04/10/23 CS 201

Codestruct Node { int element; Node * next;};

struct QUEUE { Node * front; Node * rear;};

04/10/23 CS 201

More code

More code

04/10/23 CS 201

CELL is a list node

04/10/23 CS 201

Implementation of Queue (Array)

• use Array with front and back pointers as implementation of queue Queue

arr 0 1 7 8 92 3 4 5 6

A B C D E F G

frontback

04/10/23 CS 201

Circular Array• To implement queue, it is best to view arrays as circular structure

0 1 7 8 92 3 4 5 6

A B C D E F G

frontback

front

back

AB

C

DEF

G

0

1

7

8

9

2

3

456

Circular view of arrays.

04/10/23 CS 201

How to Advance

• Both front & back pointers should make advancement until they reach end of the array. Then, they should re-point to beginning of the array

front = adv(front);back = adv(back);

int adv(int p) { return ((p+1) % maxsize); }

Alternatively, use modular arithmetic:

mod operator

int adv(int p) { int r = p+1; if (r<maxsize) return r; else return 0; }

upper bound of the array

04/10/23 CS 201

Sample

Queue *Q;

enqueue(Q, “a”);

enqueue(Q, “b”);

enqueue(Q, “c”);

dequeue(Q);

dequeue(Q);

enqueue(Q, “d”);

enqueue(Q, “e”);

dequeue(Q);

a

Q

F=front B=back

F

B

b c d

F

B B B

F F

B B

e

04/10/23 CS 201

Checking for Full/Empty State

What does (F==B) denote?

FB

QueueEmptyState

c de

B

F

f QueueFullState

size 0 size 4

c de

B F

Alternative - Leave a Deliberate Gap!

No need for size field.

Full Case : (adv(B)==F)

04/10/23 CS 201

Summary• The definition of the queue operations

gives the ADT queue first-in, first-out (FIFO) behavior

• The queue can be implemented by linked lists or by arrays

• There are many applications– Printer queues,– Telecommunication queues,– Simulations,– Etc.