M2_Linear Data Structures

Resmi N.G.

References:

Data Structures and Algorithms:

Alfred V. Aho, John E. Hopcroft, Jeffrey D. Ullman

A Practical Approach to Data Structures and Algorithms: Sanjay Pahuja

Module 2� Module II (18 hours)

� Linear Data Structures - Stacks – Queues -Lists -

Dequeues - Linked List - singly, doubly linked and

circular lists - Application of linked lists - Polynomial

Manipulation - Stack & Queue implementation using

Array & Linked List - Typical problems - Conversion of

infix to postfix - Evaluation of postfix expression –

priority queues

10/25/2012 2CS 09 303 Data Structures - Module 2

LIST

• Flexible data structure: grows and shrinks on demand.

• Elements can be accessed, inserted, or deleted at any position within

a list.

• Lists can be concatenated or split into sub-lists.

• Mathematically, a list is a sequence of zero or more elements of a

given type.

� Represented by a comma separated sequence of elements

a1,a2,…an where n>=0 and each ai is of a given type.

• n is the length of the list.


Features Of List

� Can be linearly ordered according to their position on

the list.

� Concatenation and splitting possible

� Main application areas are:

=> Information retrieval

=> Programming language translation

=> Programming language simulation


LIST OPERATIONS

� INSERT(x, p,L) : Inserts x at position p in list L.

� Move elements at p and following positions to next higher

positions.

� Insert x at position p in list L.

� If L is a1, a2, …, an, then L becomes a1, a2, …, ap-1, x, ap, …,

an.

� If p is END (L), then L becomes a1, a2, …, an, x.


� END(L) : returns the last position of list L

� LOCATE(x, L) : returns the position of x on list L.

� If x appears more than once, it returns the position of first

occurrence of x.

� If x does not appear at all, then it returns END(L).

� RETRIEVE(p,L) : returns element at position p on list L.

� Result is undefined if p = END (L) or if L has no position p.


� DELETE(p, L) : deletes the element at position p of list L.

� If list is a1,a2, …, an, then the list L becomes a1, a2, … ap-1, ap+1, …,an.

� NEXT(p, L): returns position following p on list L.

� PREVIOUS(p, L):returns position preceding p on list L.

� MAKENULL(L) : Makes the list L empty and returns the position

END(L).

� FIRST(L) : returns first position on list L.

� PRINTLIST(L) :prints elements of L in order of occurrence.


Implementation Of List2 Ways

� Array Implementation

�Pointer Implementation(Linked List representation)


Array Implementation Of List

� Elements are stored in contiguous cells of an array.

� Easily traversed

� Elements can be appended readily to the end of the list.

� Definition of LIST: is a record that contains 2 fields:

� an array of elements with maximum required length

� an integer “last” : indicating position of the last list element

in the array.


Array Implementation Of List

(Definition)const

MAXLEN = 100;

type

LIST = record

elements:array[1..MAXLEN] of elementtype;

last :integer;

end;

position = integer;


function END (var L: List) : position;

begin

return (L.last + 1) {gives total no. of elements in the

list}

end; {END}


END(L) Algorithm

0 1 2 3

50 107 15 201

L.last

INSERTION Algorithmprocedure INSERT(x : elementtype; p : position; var L: LIST)

{INSERT places x at position p in list L}

var q:position;

begin

if L.last >= MAXLEN then

error (‘list is full’)

else if (p > L.last + 1 ) or ( p < 1) then

error(‘position does not exist’)

else

begin

for q := L.last downto p do

{shift elements at p, p+1…… down by one position}

L.elements[q+1] := L.elements[q];

L.last := L.last+1;

L.elements[p] := x;

end

end;{INSERT}


Insertion

10/25/2012 CS 09 303 Data Structures - Module 2 13

0 1 2 3

47

� Insert (47, 0, L)

� L.last := L.last + 1 = -1 + 1 = 0

� L.elements[0] := 47;

L.last

p

p


0 1 2 3

47

47 59

� Insert (59, 1, L)

� L.last := L.last + 1 = 0 + 1 = 1


L.last

L.last p

p


0 1 2 3

47 59

47 59 65

� Insert (65, 2, L)

� L.last := L.last + 1 = 1 + 1 = 2


L.last

L.last p

p


0 1 2 3

47 59 65

47 59 65

� Insert (53, 1, L)

� Shift elements down to insert at position 1. Start with q = L.last.

� L.elements[q+1] := L.elements[q]

� { Move element at position 2 to position 3.

� L.elements[2+1] = L.elements[2]

� L.elements[3] = L.elements[2] }

L.last

L.lastp

q+1

q

qp


0 1 2 3

47 59 65

47 59 65

� Decrement q until q = p. So, q = 1.

� L.elements[q+1] := L.elements[q]

� { Move element at position 1 to position 2.

� L.elements[1+1] = L.elements[1]

� L.elements[2] = L.elements[1] }

L.last

L.lastp

q+1

q

qp


0 1 2 3

47 59 65

47 53 59 65

� Now, q = p = 1. So, insert element at position 1.

� L.last := L.last + 1 = 2+1 = 3;

� L.elements[p] := L.elements[1] = 53;

L.last

L.lastp q

qp

DELETION Algorithm

procedure DELETE (p:position; var L : LIST)

{DELETE removes the element at position p of list L}

var q:position;

begin

if ( p > L.last ) or ( p < 1) then

error(‘position does not exist’)

else

begin

L.last := L.last-1;

for q := p to L.last do

{shift elements at p+1, p+2, …up one position}

L.elements[q] := L.elements[q+1];

end

end;{DELETE}


Deletion


0 1 2 3

47 53 59 65

47 53 59 65

� Delete (1, L)

� L.last := L.last - 1 = 3-1= 2L.last

p

p L.last


0 1 2 3

47 53 59 65

47 59 65

� Move element at location q+1 = 2 to location q = 1.

� L.elements[q] := L.elements[q+1];

L.lastp

pL.last

� To delete element at 1, shift elements at 2 and 3 up by one

position. Start with q = p. ie. q = 1.

q

q+1q

q+1


0 1 2 3

47 59 59 65

47 59 65

� Move element at location q+1 = 3 to location q = 2.

� L.elements[q] := L.elements[q+1];

L.lastp

pL.last

� Increment q until q = L.last = 2.

� So, q = q + 1 = 2.

q q+1

q

LOCATE Algorithm

function LOCATE( x:elementtype; var L:LIST) : position;

{LOCATE returns position of x on list L}

var q:position;

begin

for q:=1 to L.last do

if L.elements[q] = x then

return(q);

else

return( L.last + 1 ) {if not found}

end;{LOCATE}


Removing Duplicates in a LIST

Procedure PURGE (Var L:List); {PURGE removes duplicate elements from list L}

Var p,q : position; {p will be the current position in L, and

q will move ahead to find equal elements}

Begin

(1) p := FIRST(L);

(2) While p <> END(L) do begin

(3) q := NEXT(p, L);

(4) while q <> END(L) do

(5) if same (RETRIEVE (p, L), RETRIEVE (q, L ) then

(6) DELETE(q,L);

(7) else

(8) q:=NEXT(q,L);

(9) p:=NEXT(p,L)

(10) End;

End; {PURGE}10/25/2012 24CS 09 303 Data Structures - Module 2

Pointer Implementation Of List:

(LINKED LIST)

• Use of special data structure - Linked List

• Singly-linked cells which use pointers to link successive list

elements are used here.

• Does not require contiguous memory for storage.

• Allocates memory dynamically

• Linked List is made up of cells, and each cell contains:

� �Element of the list

� �Pointer to next cell on the list

• If the list is a1,a2,…an, the cell holding ai has a pointer to the cell

holding ai+1, for i = 1, 2, …n-1.

• Header holds no element but points to cell holding a1. The cell

holding an has a nil pointer.



Classification Of Linked Lists

� Linear or singly linked list

� Doubly Linked List

� Circular Linked List

� Circular Doubly linked List


Linear Singly Linked List

� Definition

type

celltype = record

element:elementtype;

next: celltype;

end;

LIST= celltype;

position = celltype;


Operations Of Singly Linked List

� END(L) Algorithm

Function END(var L : List) : position;

{END returns a pointer to the last cell of L}

Var

q:position;

begin

(1) q:=L;

(2) While q .next <> nil do

(3) q:= q .next;

(4) return(q)

end; {END}


� Steps involved are :

� Find the correct location

� Insert the element


Operations Of Singly Linked List

INSERTION

Finding the Correct Location� Three possible positions:

� The front

� The end

� Somewhere in between the existing cells


head

Inserting to the Front

� There is no work to find the location.

� Insertion at the beginning of the list

48 17 142head 93


No Worries!

Inserting to the End

�Find the end of the list(when at NIL)

48 17 142head //93 //

No Worries!


Inserting to the Middle

�Used when the order isimportant.

17 48 142head //93 //142


Operations Of Singly Linked List(contd..)


� INSERTION Algorithm

Procedure INSERT(var x : elementtype, p : position);

{Inserts a cell with element ‘x’ after position ‘p’}

Var

temp : position;

Begin

(1) temp := p . next;

(2) New(p .next);

(3) p .next .element := x;

(4) p .next .next := temp;

End;{INSERT}

Explanation� (1) temp := p . next;

� {address of the cell next to p is stored in temp}


p Temp

2 6 8

head

4

� (2) New(p .next);

� {A new cell is created and its address is assigned to p .next}


p temp

p . next = address of new cell

p . next

2 6 8

head

4

� (3) p .next .element := x;

� {Element at p .next is assigned as x}


p temp

p . next . element = 5

p . next

2 6 8

head

4

5

� (3) p .next . next := temp;

� {Next of p .next is assigned as temp}


p temp

p . next

p . next . next = temp

2 6 8

head

4

5


2 6 8

head

4 5


� DELETION Algorithm

� Deletes the element after position p.

Procedure DELETE( var p:position);

Begin

p .next := p .next .next;

End;{DELETE}


4 17

head

426

Deletion at the front


Head has the address of first node

4 17

head

426


Deletion at the front

Head is made to point to the next cell.

4 17

head

42


Deletion from in between the cells

4 17

head

42




p p . next p . next . next

p . next = p . next . next


Operations Of Singly Linked

List(contd..)


� LOCATE Algorithm

Function LOCATE( var x : elementtype; var L:LIST):position;

Var p : position;

Begin

p := L;

while p . next <> nil do

if p . next . element = x then

return (p);

else

p := p . next ;

return (p) {if not found}

End;{LOCATE}

4 17

head

426

Target = 4


Deleting a particular element

4 17

head

426

Target = 4


Start searching from the beginning of the list L.

Initially, p = L;

p

4 17

head

426

Target = 4


Check if p.next.element = 4.

NO. So, move onto next cell.

p = p.next

p

4 17

head

426

Target = 4


p

Check if p.next.element = 4.

YES. So, perform the operation

p.next = p.next.next

4 17

head

426

Target = 4


p .next = p.next.nextp

4 17

head

426

Target = 4


17

head

426



� MAKENULL Algorithm

Function MAKENULL(Var L:LIST):position;

Begin

new(L);

L .next := nil;

return(L);

End; {MAKENULL}


Creates an empty list L

Doubly Linked List� Each cell has a pointer to the next and previous cells

on the list.

� Given an element, it is easy to determine the preceding and following elements quickly.

� Can be used to traverse a list in both forward and backward directions.




Doubly Linked ListDefinition

Type

celltype = record

element : elementtype;

next , previous : celltype;

End;

position = celltype;

newnode = celltype;


Doubly Linked ListINSERTION ALGORITHM

Procedure INSERT( var element:elementtype; varpos:position)

Var Temp : position;

Begin

Temp := L;

i : =1;

while (i < pos and Temp < > NIL )

begin

Temp : = Temp . Next;

i : = i + 1;

End;


If Temp < > NIL and i = pos then

begin

New( newNode);

newNode .element : = element;

newNode .next : = Temp .next;newNode . previous : = Temp;

Temp .next . previous : = newNode;Temp . next := newNode;

end { if }Else begin

error ( ‘position not found ’ )end; { INSERT}


Explanation


5 15 20

head

Check if i<pos, and temp<>NIL.

i=1, pos = 2 and temp<>NIL.

So, move forward.

temp = temp.next

i = i+1

temp

temp := L;

i : =1;


5 15 20

head

temp Check if i<pos, and temp<>NIL.

i=2, pos = 2 and temp<>NIL.

So, do insertion.


5 15 20

head

temp

If Temp < > NIL and i = pos then

begin

new( newNode); {Creates a new node in memory and assigns

its address to ‘newnode’.}

newNode .element : = element; {Inserts element at newnode.}

10


5 15 20

head

temp

10 newNode .next : = temp .next;


5 15 20

head

temp

10

newNode . previous : = temp;


5 15 20

head

temp

10

temp .next . previous : = newNode;

temp . next


5 15 20

head

temp

10

temp .next : = newNode;


5 15 20

head

10

Deletion in Doubly Linked List


DELETION ALGORITHM

Procedure DELETE ( Var p : position);

Begin

if p . Previous < > nil then

{ deleted cell not the first }

p . Previous . Next : = p . Next;

if p . Next < > nil then

{ deleted cell not the last }

p . Next . Previous : = p . Previous

End { DELETE}



p

p . previous . next = p . next;

p. next . previous = p . previous ;

STACK

• An Abstract Data Type

• Special List : insertions & deletions at one

end(top)

• Also called LIFO(Last In First Out) list.




Operations performed on stack

� MAKENULL(S) : Make stack S an empty stack.

� TOP(S) : Return the top element of stack S.

� POP(S) : Delete the top element from the stack. {check

for stack empty condition}

� PUSH(x,S) : Insert the element x at the top of stack S.

{ Stack overflow condition should be checked}

� EMPTY(S) : Returns true if S is an empty stack.


Stack Implementation

� Static implementation(Using arrays)

� Dynamic implementation(Using pointers)


Definition of Array-Based Stack� type

� STACK = record

� top : integer;

� elements : array[1..MAXLENGTH] of elementtype;

� end;


Array Implementation

Procedure PUSH( var x:elementtype; Var s:STACK);

Begin

If s.top = MAXLENGTH -1 then

error(‘stack is full’)

Else

begin

s.top:=s.top+1;

s.elements[s.top]:=x;

End;

End;{PUSH}


� Initial stack


3

2

1

0

Top = -1

� Push (12, S)


s.top:=s.top+1 = -1 + 1 = 0;

s.elements[s.top]:= s.elements[0] = 12;

3

2

1

0 12 Top = 0

� Push (34, S)


s.top:=s.top+1 = 0 + 1 = 1;


3

2

1 34

0 12

Top = 1

� Push (47, S)


s.top:=s.top+1 = 1 + 1 = 2;


3

2 47

1 34

0 12

Top = 2

� Push (53, S)


s.top:=s.top+1 = 2 + 1 = 2;


3 53

2 47

1 34

0 12

Top = 3

� Stack full (Top = max-1);

Procedure POP( Var s:STACK);

begin

if EMPTY(s) then

error(‘stack is empty’)

else

s.top := s.top-1;

end;{POP}


Procedure MAKENULL( Var s:STACK);

Begin

s.top:= -1;

End;{MAKENULL}


Function EMPTY( Var s:STACK):boolean;

begin

If s.top<0 then

return(true);

else

return(false);

end;{EMPTY}


Function TOP ( Var s:STACK):elementtype;

begin

If EMPTY(s) then

error(‘stack is empty’)

else

return(s.elements[s.top]);

end;{TOP}


Applications of stack� Explicit and implicit recursive calls

� Conversion of Infix to postfix

� Postfix expression evaluation

� Conversion of infix to prefix

� Prefix expression evaluation

� Parenthesis checker


Applications of stack� Expression : operands together with operator

Infix notation(A+B)

Prefix notation( +AB)

Postfix notation( AB+)

� Operator precedence

^ (Exponential ) ………….Highest

*, /(mul, div) ………… Next highest

+, - (add,sub) ………… Lowest


Applications of stack

� Conversion from infix to postfix

Rules

1. Parenthesize the expression starting from left to right

2. The operands associated with the operator having higher

precedence will be parenthesized first.

3. The sub expression which has been converted to postfix

is to be treated as single operand.

4. Once the expression is converted to postfix form,

remove the parenthesis


Infix to postfix conversion

algorithmP =>postfix expression

Q =>infix expression

(1) Push “(“ onto stack and add “)” to the end of Q.

(2) Scan Q from left to right and repeat steps 3 to 6 for eachelement of Q until the stack is empty.

(3) If an operand is encountered, add it to P.

(4) If an operator # is encountered, then

(a) Repeatedly pop from stack and add to P eachoperator (on the top of stack) which has equal or higherprecedence than #.


(b) Add # to stack.

5. If a left parenthesis is encountered, push it onto the

stack.

6. If a right parenthesis is encountered then

(a) Repeatedly pop from stack and add to P, until a

left parenthesis is encountered.

(b) Remove the left parenthesis.

[ do not add the left parenthesis to P].

7. Exit

# �Symbolizes any operator in Q




Evaluating Postfix expression(1) Add a right parenthesis “)” at the end of P[this acts as a

sentinel].

(2) Scan P from left to right and repeat steps 3 and 4 foreach element of P until the sentinel “)” is encountered.

(3) If an operand is encountered, put it on STACK.


(a) Remove the two top elements of STACK ,where A isthe top element and B is the next-to-top element.

(b) Evaluate B # A.

(c) Place the result onto STACK.

5) RESULT equal to the top element on stack.

6) Exit



Evaluate 45+72-*

Evaluate 59+2*65*+


Infix to prefix conversion algorithmI => infix expression

O => output expression

P => prefix expression

(1) Push “)“ onto stack and add “(” to the beginning of I.

(2) Scan I from right to left and repeat steps 3 to 6 for eachelement of I until the stack is empty.

(3) If an operand is encountered, add it to O.


(a) Repeatedly pop from stack and add to O eachoperator (on the top of stack) which has higherprecedence than #.


(b) Add # to stack.

5. If a right parenthesis is encountered, push it onto the

stack.

6. If a left parenthesis is encountered then

(a) Repeatedly pop from stack and add to O, until a

right parenthesis is encountered.

(b) Remove the right parenthesis.

[ do not add the right parenthesis to O].

7. Reverse O to get the prefix expression P.

8. Exit

# �Symbolizes any operator in I.10/25/2012 100CS 09 303 Data Structures - Module 2

Convert (A*B-F*H)^D


Symbol Scanned Operator Stack Output Expression

D ) D

^ )^ D

) )^) D

H )^) DH

* )^)* DH

F )^)* DHF

- )^)- DHF*

B )^)- DHF*B

* )^)-* DHF*B

A )^)-* DHF*BA

( )^ DHF*BA*-

( (Empty) DHF*BA*-^

Result: ^-*AB*FHD

Home Work� Convert to prefix:

� A+ [ B+C - D+E] * F / G

� +A/*+-+BCDEFG

� (a–b)/c*(d + e – f / g)

� */-abc-+de/fg


Convert (a–b)/c*(d + e – f / g)

10/25/2012 CS 09 303 Data Structures - Module 2 */-abc-+de/fg103

Evaluating Prefix expression(1) Add a left parenthesis “(” at the beginning of P[this acts

as a sentinel].

(2) Scan P from right to left and repeat steps 3 and 4 foreach element of P until the sentinel “(” is encountered.

(3) If an operand is encountered, push it onto STACK.


(a) Remove the two top elements of STACK ,where A isthe top element and B is the next-to-top element.

(b) Evaluate A # B.

(c) Place the result onto STACK.

5) RESULT equal to the top element on stack.

6) Exit



Evaluate *+45-72

Parenthesis Checker

� To check whether a mathematical expression is properly

parenthesized or not.

� 3 sets of grouping symbols

�The standard parenthesis ()

�The braces { }

� The brackets []


Algorithm for Parenthesis

Checker

� Make an empty stack.

� Read symbols until end of file is reached.

� If the symbol is an opening symbol, push it onto the stack.

� If it is a closing symbol, do the following:

� If the stack is empty, then report an error.

� Otherwise, pop the stack. If the symbol popped does not

match the closing symbol, then report an error.

� At the end of the file, if the stack is not empty, then report an error.


Algorithm for parenthesis checkerBegin

read expression

for each character c in expression

if(current symbol or character is a left symbol) then

push the character onto stack.

else if (current symbol is a right symbol ) then

if(stack is empty) then

print (“Error no matching open symbol”)

exit


……

else

pop a symbol s from the stack

if (s does not correspond to c ) then

print “ error incorrect nesting of symbols”

exit

end {if}

end {if}

end {if}

end {for}


……

if (stack is not empty ) then

print “ error missing closing symbol”

else

print “ input expression is OK”

end {if}

END


Self-Study (Homework)� Stack using Linked List

� Write algorithms to:

� Push an element onto stack

� Pop an element

� Create an empty stack

� Check if stack is empty

� Return the top element from the stack


QUEUES

• Abstract data type which is special kind of List where items are

inserted at one end (rear) and deleted from the other end

(front).

• Insertion :Rear

• Deletion :Front

• Also called FIFO(First In First Out) list.



front rear

QUEUE OPERATIONS

� MAKENULL(Q) : makes queue Q an empty list

� FRONT(Q) : returns first element of Q

� ENQUEUE(x, Q) : inserts element x at end of Q

� DEQUEUE(Q) : deletes first element of Q

� EMPTY(Q) : returns true if Q is an empty queue.




IMPLEMENTATION OF QUEUE

� Using Arrays

(Static implementation)

� Using Pointers

(Dynamic implementation)


Array Implementation� Type

� QUEUE = record

� elements : array[1..MAXLENGTH] of

� elementtype;

� front, rear: integer;

� end;


Queue operations using Arrays(1) Insertion Operation

procedure ENQUEUE( Var data:integer, Var Q: QUEUE)

begin

read(data);

If Q.rear >= SIZE then begin

error(‘Queue Overflow”); exit();

end

else

Q.rear := Q.rear+1;

end;

Q.elements[Q.rear] := data;

end;{ENQUEUE}


(1)Empty Queue

(2)ENQUEUE(10,Q)

(3) ENQUEUE(3,Q)

10

10 3

frontrear

0 1 2 3

0 1 2 3

Rear := -1

Front := -1

0 1 2 3

front rear


Front := 0

Rear := rear + 1 = 0

Q[Rear] := Q[0] = 10

Rear = rear + 1 = 0 + 1 = 1

Q[Rear] := Q[1] = 3

frontrear

(4)ENQUEUE(17,Q)

(5)ENQUEUE(29,Q)


Rear := rear + 1 = 2+1 = 3

Q[Rear] := Q[3] = 29

10 3 17

0 1 2 3

front rear

10 3 17 29

0 1 2 3

front rear

Rear := rear + 1 = 1 + 1 =2

Q[Rear] := Q[2] = 17

� Queue Full (rear = max - 1)

(2) Deletion Operation

Function DEQUEUE(Var Q: QUEUE) : elementtype;

Begin

if Q.rear < Q.front then begin

Q.front:=0; Q.rear:= -1;

error(‘Queue is empty”); exit();

end

else begin

dequeue := Q.elements[Q.front];

Q.front:= Q.front+1;

end;

end;{DEQUEUE}


(1)DEQUEUE(Q)

(1)DEQUEUE(Q)

(2)DEQUEUE(Q)


3 17 29

0 1 2 3

front rear

17 29

0 1 2 3

front rear

data := Q[front] = Q[0] =10

front := front + 1 = 0 + 1 = 1

data := Q[front] = Q[1] = 3

front := front + 1 = 1 + 1 = 2

data := Q[front] = Q[2] = 17

front := front + 1 = 2 + 1 = 3

29

0 1 2 3

front rear

(4)DEQUEUE(Q)


0 1 2 3

front = 4rear

data := Q[front] = Q[3] = 29

front := front + 1 = 3 + 1 = 4

� Queue empty (rear < front)

Queue operations using Pointers

(1) Definition of Queue

type

celltype = record

element: elementtype;

next : celltype;

end;

type

QUEUE = record

front, rear : celltype;

end;


(1) To Make a NULL QUEUE

procedure MAKENULL(Var Q:QUEUE);

begin

new(Q.front);{create header cell }

Q.front .next := nil;

Q.rear := Q.front; {header is both first &last cell }

end;{MAKENULL}


(2) Check if QUEUE is empty

function EMPTY(Var Q:QUEUE): boolean;

begin

if Q.front = Q.rear then

return(true);

else

return(false);

end;{EMPTY}


� (3) Returning first element from a queue

� function FRONT(Var Q:QUEUE):elementtype

� begin

� If EMPTY(Q) then

� error(‘Queue is empty’);

� else

� return(Q . front . next . element)

� end;{FRONT}

�


� (4) Insertion into a queue

� Procedure ENQUEUE( var x:elementtype;Var

Q:Queue);

� begin

� new(Q.rear . next);

� {add new cell to rear of queue}

� Q.rear := Q.rear . next;

� Q. rear .element := x;

� Q.rear .next:=nil;

� end; {ENQUEUE}


� (5) Deletion from a queue

� Function DEQUEUE(Var Q:Queue): elementtype;

� Begin

� if EMPTY(Q) then

� error(‘queue is empty’)

� else begin

� dequeue := Q.front .element;

� Q.front := Q.front .next;

� end;

� end; {DEQUEUE}


Different Types Of Queue

� Circular Queue

� Double ended Queue

� Priority Queue


Circular Queue


CIRCULAR QUEUE

� Q[1] following Q[n]

� Conditions of circular Queue:

�Insertion Condition

�Deletion Condition

�

�QUEUE FULL

rear = (rear+1) % SIZE

front = (front + 1) % SIZE

rear = front


Algorithms of Circular Queue� Insertion

Procedure ENQUEUE(Var data:integer,Var Q : QUEUE);

Begin

if Q.front = ((Q.rear + 1) % SIZE) then

begin

error(‘Queue Full’)

exit();

end

else begin

Q.rear := (Q.rear + 1) % SIZE;

end;

if Q.front = -1 then begin

Q.front := 0; Q.rear := 0;

end;

read(data);

Q.elements[Q.rear] := data;

end;{ENQUEUE}



0 1

23

Rear=-1 Front=-1

Queue is empty (front = rear = -1)


0 1

23

Rear = 0

Front = 0

Enqueue (14, Q)

Rear := (rear + 1) % SIZE = (-1 + 1) % 4 = 0 % 4 = 0

Q.elements[0] := 14;

14


0 1

23

Rear = 1

Front = 0

Enqueue (42, Q)

Rear := (rear + 1) % SIZE = (0 + 1) % 4 = 1 % 4 = 1


1442


0 1

23Rear = 2

Front = 0

Enqueue (20, Q)

Rear := (rear + 1) % SIZE = (1 + 1) % 4 = 2 % 4 = 2


1442

20


0 1

23Rear = 3

Front = 0

Enqueue (37, Q)

Rear := (rear + 1) % SIZE = (2 + 1) % 4 = 3 % 4 = 3


1442

2037

Queue full


0 1

23Rear = 3

Front = 0

Queue full

front := (rear + 1) % SIZE = (3 + 1) % 4 = 4 % 4 = 0

1442

2037

� Deletion

Function DEQUEUE(Var Q : QUEUE): elementtype;

begin

if Q.front = -1 then begin

error(‘Queue is empty’)

exit();

end

else dequeue := Q.elements[Q.front];

Q.front := (Q.front + 1) % SIZE;

end;{DEQUEUE}


Is this situation possible in a

circular queue?


Double-ended Queue (DEQUEUE)� Homogeneous list

� Insertion &deletion can be done at both ends.

� 2 types of dequeue:

(1) Input restricted queue (insertion: rear end

deletion: both ends)

An input-restricted dequeue is one where deletion can be madefrom both ends, but insertion can only be made at one end.

(2)Output restricted queue (insertion: both ends

deletion: front end)

An output-restricted dequeue is one where insertion can bemade at both ends, but deletion can be made from one endonly.


Operations on Dequeue

(1) Add an element at the rear end ( insert right)

(2)Delete an element from the front end ( delete left )

(3) Add an element at the front end ( insert left )

(4) Delete an element from the rear end (delete right )


Insert an element at the right side of

dequeue

procedure insertRightDequeue(Var data: integer, Var Q: QUEUE);

Begin

read(data);

if ((Q.left = 0 && Q.right = MAX - 1) || (Q.left = Q.right + 1)) then

begin

error(‘Queue overflow ‘);

exit();

end;


……

if Q.left = -1 then begin

Q.left := 0; Q.right := 0;

end

else begin

if Q.right = MAX-1 then

Q.right := 0;

else

Q.right := Q.right+1;

end;

Q.elements[Q.right] := data;

end; {insertRightDequeue}



0 1 2 3

� Empty Queue (If left = right = -1)

l r

Insert an element at the right side of

dequeue


0 1 2 3

5

� insertRightDequeue ( 5, Q)

left = 0 right = 0

� Set left = 0, right = 0;

� Insert at 0.

� Q.elements[right] : = Q.elements[0] = 5;


0 1 2 3

5 2


� Increment right.

� Right := right + 1 = 0 + 1 = 1;

� Insert at right.


left = 0 right = 1


0 1 2 3

5 2 10



� Right := right + 1 = 1 + 1 = 2;



left = 0 right = 2


0 1 2 3

5 2 10 17



� Right := right + 1 = 2 + 1 = 3;



left = 0 right = 3

� Queue full (left = 0 and right = MAX – 1 = 4 – 1 = 3)


0 1 2 3

2 10 17

� Perform a delete operation.

� So, left will be incremented by one.

� left := left + 1 = 0 + 1 = 1;

left = 1 right = 3


0 1 2 3

15 2 10 17

� insertRightDequeue (15, Q)

� 15 can be inserted at 0.

� If left <> -1 and right = MAX – 1, there are vacant positions at the

beginning of the queue.

� Set right = 0 and insert at 0.

left = 1right = 0

� Queue full (left = right + 1= 0 + 1 = 1)

Insert an element at the left side of

dequeue

procedure insertLeftDequeue(Var data:integer, Var Q: QUEUE);

Begin

read(data);

if((Q.left = 0 && Q.right = MAX - 1) | | (Q.left = Q.right+1))

then begin

error(‘Queue overflow ‘);

exit();

end


if Q.left = -1 then begin

Q.left := 0; Q.right := 0;

end

else begin

if Q.left = 0 then

Q.left := MAX-1;

else

Q.left := Q.left-1;

end;

Q.elements[Q.left] := data;

end; {insertLeftDequeue}



0 1 2 3

� Empty Queue (If left = right = -1)

l r

Insert an element at the left side of

dequeue


0 1 2 3

5

� insertLeftDequeue ( 5, Q)

left = 0 right = 0

� Set left = 0, right = 0;

� Insert at 0.

� Q.elements[left] : = Q.elements[0] = 5;


0 1 2 3

5 2


� If left = 0, set left = MAX - 1.

� left := MAX - 1 = 4 - 1 = 3;

� Insert at left.


left = MAX- 1right = 0


0 1 2 3

5 10 2


� Decrement left.

� left := left - 1 = 3 - 1 = 2;

� Insert at left.


right = 0 left = 2


0 1 2 3

5 17 10 2


� Decrement left.

� left := left - 1 = 2 - 1 = 1;

� Insert at left.


right = 0 left = 1

� Queue full (left = right + 1 = 0 + 1 = 1)


0 1 2 3

17 10 2

� Perform a delete operation.

� Right will be set to MAX – 1 so that element at zero is deleted first.

� right := MAX - 1 = 4 - 1 = 3;

left = 1 right = 3


0 1 2 3

15 2 10 17

� insertLeftDequeue (15, Q)

� 15 can be inserted at 0.

� If left <> -1 and left <> 0, there are vacant positions at the beginning

of the queue.

� Set left := left - 1 = 2 -1 = 0 and insert at 0.

left = 0

� Queue full (left = 0 and right = MAX - 1)

right = 3

Dequeue Operations(Normal

Queue Operations)� Insert Right (Rear) and Delete Left (Front)

� Insert Left (Front) and Delete Right (Rear)


Delete an element from the right side

of dequeue

procedure deleteRightDequeue(Var Q: QUEUE);

Begin

Var data: integer;

if((Q.left = -1) then begin

error(‘Queue underflow ‘);

exit();

end;{if}

data := Q.elements[Q.right];


if (Q.left = Q.right ) then begin {only one element}

Q.left:= -1; Q.right := -1;

end;{if}

if (Q.right = 0) then

Q.right = MAX -1;

else

Q.right = Q.right -1;

end; { deleteRightDequeue}



0 1 2 3

5 2 10 17

� deleteRightDequeue ( Q)

� Right = 0.

� So, delete the first element.

� data := Q.elements[right] = Q.elements[0] = 5;

� Set Right := MAX - 1 = 3; {Next deletion occurs at right = 3}.

left = 1right = 0

Delete an element from the right side

of dequeue


0 1 2 3

2 10 17


� Right = 3.


� Set Right := right - 1 = 3 – 1 = 2;

left = 1 right = 3


0 1 2 3

2 10


� Right = 2.


� Set Right := right - 1 = 2 – 1 = 1;

left = 1 right = 2


0 1 2 3

2

� deleteRightDequeue (Q)

left = 1 right = 1

� data : = Q.elements[right] : = Q.elements[1] = 5;

� Left = right = 1; {only one element}

� Set left := -1, right := -1; {Queue becomes empty}


0 1 2 3

� Empty Queue (left = right = -1)

� Cannot perform deletion

l r

� deleteRightDequeue (Q)

Delete an element from the left side

of dequeue

procedure deleteLeftDequeue(Var data:integer,Var Q:

QUEUE);

Begin

if((Q.left = -1) then begin

error(‘Queue underflow ‘);

exit();

end;{if}

data:=Q.elements[Q.left];


if Q.left = Q.right then begin {only one element}

Q.left:= -1; Q.right := -1;

end;{if}

if ( Q.left = MAX - 1 ) then

Q.left = 0;

else

Q.left = Q.left + 1;

end; { deleteLeftDequeue}



0 1 2 3

12 27 60 18

� deleteLeftDequeue ( Q)

� Left = 0.

� So, delete the first element.

� data := Q.elements[left] = Q.elements[0] = 12;

� Set left := left + 1 = 1; {Next deletion occurs at left = 1}.

left = 0 right = 3

Delete an element from the left side of

dequeue


0 1 2 3

27 60 18


� Left = 1.


� Set left := left + 1 = 1 + 1 = 2;

left = 1 right = 3


0 1 2 3

60 18


� Left = 2.


� Set left := left + 1 = 2 + 1 = 3;

left = 2 right = 3


0 1 2 3

18

� deleteLeftDequeue (Q)

left = 3 right = 3

� data : = Q.elements[left] : = Q.elements[3] = 18;

� Left = right = 3; {only one element}

� Set left := -1, right := -1; {Queue becomes empty}


0 1 2 3

� Empty Queue (left = right = -1)

� Cannot perform deletion

l r

� deleteLeftDequeue (Q)

Example� Insert right (rear)


0 1 2 3

21

left = 0 right = 0


� Insert left (front)

0 1 2 3

21 42

left = 3right = 0


� Insert right (rear)

0 1 2 3

21 35 42

left = 3right = 1


� Insert left (front)

0 1 2 3

21 35 5 42

left = 2right = 1


� Delete left (front)

0 1 2 3

21 35 42

left = 2right = 1


� Delete right (rear)

0 1 2 3

21 42

left = 2right = 0


� Delete right (rear)

0 1 2 3

42

left = 2 right = 3


� Delete left (rear)

0 1 2 3

l ,r = -1

PRIORITY QUEUE

� Collection of elements such that each element is assigned a

priority number.

�Rules are:

� An element of higher priority is processed before any

element of lower priority.

� Elements of same priority are processed according to the

order in which they were added into the queue.


Two types of priority queues� Ascending priority queue

� Items are inserted arbitrarily and element with least priority

is removed.

� Descending priority queue

� Items are inserted arbitrarily and element with highest

priority is removed.


Implementation�Implementation of priority queue:

(1) One way list representation

(2) Multiple Queues (one for each priority - Array

representation)

(3) Maximum or minimum heap


One Way List Representation

� Each node contains:

� INFO: Information field

� PRT : Priority number

� NEXT: Next pointer

A node x precedes a node y in the list when x has higher

priority than y or when both have same priority but x was

inserted before y.


� Operations performed:

� Searching an element with maximum priority

� Inserting an element

� Deleting an element with maximum priority


� Insert A with priority number 2.


Start

A 2 NULL

� Insert B with priority number 1.


Start

B 1 A 2 NULL


Start

B 1 A 2 C 2 NULL

� Insert C with priority number 2.


Start

B 1 A 2 C 2 NULL

� Delete operation deletes element with highest priority.


Start

A 2 C 2 NULL

� Delete operation deletes element with highest priority.

Insertion algorithm of one way list

representation of priority queue

(1) Traverse the one – way list until you find a node X

whose priority number exceeds N (item to be inserted).

(2) Insert ITEM N in front of node X.

(3) If no such node is found, insert ITEM as the last element

of the list.


Deletion algorithm of one way list


(1) Set ITEM := INFO[START] { This saves the data in the

first node }

(2) Delete first node from the list

(3) Process ITEM

(4) Exit


Array Implementation� As multiple queues.

� Multiple queues are defined in the same array queue[] of

size n.

� Each queue i is allocated a predefined space bounded by

array indices.

� A queue is maintained for each priority.

� In order to process an element of the priority queue,

element from non-empty highest priority number queue is

accessed.



Queue1 Queue2 Queue3 Queue4

front[0] front[1] front[2] front[3]rear[0] rear[1] rear[2] rear[3]

Insertion algorithm of array


(1) Insert ITEM as the rear element in row M of QUEUE.

(2)Exit


Deletion algorithm of array


(1)Find the smallest k such that FRONT[K]!=NULL.

{Find the first non-empty queue}

(2)Delete and process the front in row k of queue.

(3) Exit


Comparison of array & one way

list representation

� Array :Time efficient

One way list :Space efficient


Applications of Queue� Round robin techniques :Process scheduling

� Print server routines

� All types of customer service software(Railway/airticket reservation)


Application of linked lists

Polynomial Manipulation

� Polynomial of single variable of degree m

� f(x) = amxm + am-1xm-1 + … + aix

i + … + a1x + a0

� ai are non-zero coefficients with exponents i.

� Each term is represented by a node with three fields,

which represent the coefficient, exponent of a term and a

pointer to the next term.


� A term of a polynomial of single variable x:

� p = 6x5 + 2x3 + x + 4

� Store the polynomial in descending order of powers.


powerx coef next

5 6 1570

1526

3 2 1607

1570

1 1 1750

1607

0 4 NULL

1750

� A term of a polynomial of variables x, y, z:

� p = 2x3 + 3xy + y2 + yz

� Store the polynomial such that terms are arranged in

descending order of powers of x first, then y and then z.


Power x Power y Power z coef next

3 0 0 2 1 1 0 3 0 2 0 1 0 1 1 1

Addition of Two Polynomials of

Single variable� p = 6x5 + 2x3 + x + 4

� q = 2x4 + 10 x + 1


6x5 + 2x3 + x + 4

2x4 + 10 x + 1

6x5 + 2x4 + 2x3 + 11 x + 5

� p.powerx > q.powerx (Add first term of p. Increment ptrp)


5 6 1570

1526

3 2 1607

1570

1 1 1750

1607

0 4 NULL

1750

4 2 1660

1500

1 10 1700

1660

0 1 NULL

1700

5 6

1826

ptrq

ptrp

ptrr

� p.powerx < q.powerx


5 6 1570

1526

3 2 1607

1570

1 1 1750

1607

0 4 NULL

1750

4 2 1660

1500

1 10 1700

1660

0 1 NULL

1700

5 6 1870

1826

4 2 Null

1870

ptrq

ptrr

ptrp

� p.powerx > q.powerx


5 6 1570

1526

3 2 1607

1570

1 1 1750

1607

0 4 NULL

1750

4 2 1660

1500

1 10 1700

1660

0 1 NULL

1700

5 6 1870

1826

4 2 1860

1870

ptrq

ptrp

ptrr

3 2 Null

1860

� p.powerx = q.powerx (Add the coefficients and increment both the pointers)


5 6 1570

1526

3 2 1607

1570

1 1 1750

1607

0 4 NULL

1750

4 2 1660

1500

1 10 1700

1660

0 1 NULL

1700

5 6 1870

1826

4 2 1860

1870

ptrp

3 2 1807

1860

1 11 Null

1807ptrr

ptrq

� p.powerx = q.powerx (Add the coefficients)


5 6 1570

1526

3 2 1607

1570

1 1 1750

1607

0 4 NULL

1750

4 2 1660

1500

1 10 1700

1660

0 1 NULL

1700

5 6 1870

1826

4 2 1860

1870

ptrp

3 2 1807

1860

1 11 1950

1807

ptrq

0 5 NULL

1950ptrr

Algorithm for polynomial addition

(single variable)1. Repeat upto step 3 while there are terms in both polynomials yet

to be processed.

2. Obtain values for terms from each polynomial.

3. If the powers associated with the two terms are equal then

� If the sum of coefficients of both terms is not zero then

� Insert sum of the coefficients into the sum polynomial.

� Obtain the next terms from both polynomials.


� Else if the power of first polynomial > power of the

second polynomial then

� Insert the term from first polynomial into sum polynomial.

� Obtain the next term in the first polynomial.

� Else

� Insert the term from second polynomial into sum

polynomial.

� Obtain the next term in the second polynomial.

4. Copy remaining terms from non-empty polynomial into sum

polynomial.

5. Return the address of the sum polynomial.


Thank You


Documents

M2_Linear Data Structures