Chapter 3 Stacks and Queues

The Stack Abstract Data Type The Queue Abstract Data Type A Mazing Problem Evaluation of Expressions

3.1 The stack ADT (1/5)

A stack is an ordered list in which insertions and
deletions are made at one end called the top. If we add the elements A, B, C, D, E to the stack, in that order, then E is the first element we delete from the stack A stack is also known as a Last-In-First-Out (LIFO) list.

3.1 The stack ADT (2/5)

An application of stack: stack frame of function call
(activation record)
fp: a pointer to current stack frame

old frame pointer return address local variables old frame pointer return address

fp al

old frame pointer

stack frame of invoking function

fp main

return address

system stack before a1 is invoked

system stack after a1 is invoked

(a) (b) *Figure 3.2: System stack after function call a1 (p.103)

3.1 The stack ADT (3/5)

The ADT specification of the stack is shown in
Structure 3.1

3.1 The stack ADT (4/5)

Implementation: using array

3.1 The stack ADT (5/5)

3.2 The queue ADT (1/7)

A queue is an ordered list in which all insertion take
place one end, called the rear and all deletions take place at the opposite end, called the front If we insert the elements A, B, C, D, E, in that order, then A is the first element we delete from the queue A stack is also known as a First-In-First-Out (FIFO) list

3.2 The queue ADT (2/7)

The ADT specification of the queue appears in
Structure 3.2

3.2 The queue ADT (3/7)

Implementation 1:
using a one dimensional array and two variables, front and rear

3.2 The queue ADT (4/7)

problem: there may be available space when IsFullQ is true i.e. movement is required.

3.2 The queue ADT (5/7)

Example 3.2 [Job scheduling]:
Figure 3.5 illustrates how an operating system might process jobs if it used a sequential representation for its queue.

As jobs enter and leave the system, the queue gradually shift
to right. In this case, queue_full should move the entire queue to the left so that the first element is again at queue[0], front is at -1, and rear is correctly positioned.
Shifting an array is very time-consuming, queue_full has a worst case complexity of O(MAX_QUEUE_SIZE).

 We can obtain a more efficient

3.2 (6/7)
Implementation 2:

representation if we regard the array queue[MAX_QUEUE_SIZE] as circular.

regard an array as a circular queue

front: one position counterclockwise from the first element current end

rear:

Problem: one space is left when queue is full.

 Implementing addq and deleteq for a circular queue

3.2 (7/7)

is slightly more difficult since we must assure that a circular rotation occurs.

3.3 A Mazing Problem (1/8)

Representation of the maze
The most obvious choice is a two dimensional array 0s the open paths and 1s the barriers Notice that not every position has eight neighbors. entrance To avoid checking for these border 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
conditions we can surround the maze by a border of ones. Thus an mp maze will require an (m+2) (p+2) array The entrance is at position [1][1] and the exit at [m][p]
1 0 1 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 1 0 0 0 1 1 0 1 1 1 0 0 1 1 1 1 1 0 1 1 0 0 0 0 1 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 0 1 1 0 1 1 0 0 1 1 1 1 0 1 0 0 1 0 1 1 1 1 1 1 1 1 1 0 0 1 1 0 1 1 1 0 1 0 0 1 0 1 1 1 0 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0 1 1 0 1 1 1 1 1 0 1 1 1 1 1 0 0 0 1 1 0 1 1 0 0 0 0 0 1 1 0 0 1 1 1 1 1 0 0 0 1 1 1 1 0 1

1 0 1 0 0 1 1 1 1 1 0 1 1 1 1 0 1

exit

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

3.3 A Mazing Problem (2/8)

If X marks the spot of our current location,
maze[row][col], then Figure 3.9 shows the possible moves from this position

3.3 A Mazing Problem (3/8)

A possible implementation:
Predefinition: the possible directions to move in an array, move, as in Figure 3.10. Obtained from Figure 3.9
typedef struct { short int vert; short int horiz; } offsets; offsets move[8]; /*array of moves for each direction*/

If we are at position, maze[row][col], and we wish to find the position of the next move, maze[row][col], we set:
next_row = row + move[dir].vert; next_col = col + move[dir].horiz;

3.3 A Mazing Problem (4/8)

Initial attempt at a maze traversal algorithm
maintain a second two-dimensional array, mark, to record the maze positions already checked use stack to keep pass history

#define MAX_STACK_SIZE 100 /*maximum stack size*/ typedef struct { short int row; short int col; short int dir; } element; element stack[MAX_STACK_SIZE];

R3 C12 5 R4 C14 D 2 R3 C13 D 3 6 R2 C12 D 3 R2 C11 D 2 R1 C10 D 3

R1C1D1

R: row C: col D: dir

Pop out

maze[1][1]: entrance
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 0 1 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 1 0 0 0 1 1 0 1 1 1 0 0 1 1 1 1 1 0 1 1 0 0 0 0 1 1 1 1 0 0 1 1 1 1 1 1 0 1 1 1 1 0 1 1 0 1 1 0 0 1 1 1 1 0 1 0 0 1 0 1 1 1 1 1 1 1 1 1 0 0 1 1 0 1 1 1 0 1 0 0 1 0 1 1 1 0 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 0 1 1 0 1 1 1 1 1 0 1 1 1 1 1 0 0 0 1 1 0 1 1 0 0 0 0 0 1 1 0 0 1 1 1 1 1 0 0 0 1 1 1 1 0 1

Initially set mark[1][1]=1

R1C9D2
R1C8D2 R2C7D1 R3C6D1

R3C5D2
R2C4D3 R1C5D5 R1C4D2 R1C3D2 R2C2D1

1 0 1 0 0 1 1 1 1 1 0 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

R1C1D1 3

maze[15][11]: exit

3.3 A Mazing Problem (6/8)

Review of add and delete to a stack

 Analysis:

3.3 A Mazing Problem (7/7)

The worst case of computing time of path is O(mp), where m and p are the number of rows and columns of the maze 0 respectively 7 N 1
6 W E 2 5 S 3 4

(1,1) (m,p) (m+2)*(p+2)

3.3 A Mazing Problem (8/8)

The size of a stack
0 1 1 0 1 1 1 0 1 0 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 1 0 1 1 1 0 1 1 0

m*p

mp m / 2 / p, or p / 2 / m

*Figure 3.11: Simple maze with a long path (p.116)

3.4 Evaluation of Expressions (1/14)

3.4.1 Introduction
The representation and evaluation of expressions is of great interest to computer scientists. ((rear+1==front) || ((rear==MAX_QUEUE_SIZE-1) && !front)) (3.1) x = a/b - c+d*e - a*c (3.2) If we examine expressions (3.1), we notice that they contains: operators: ==, +, -, ||, &&, ! operands: rear, front, MAX_QUEUE_SIZE parentheses: ( )

3.4 Evaluation of Expressions (2/14)

Understanding the meaning of these or any other
expressions and statements
assume a = 4, b = c = 2, d = e = 3 in the statement (3.2), finding out the value of x = a/b c + d*e - a*c Interpretation 1: ((4/2)-2)+(3*3)-(4*2) = 0+8+9 = 1 Interpretation 2: (4/(2-2+3))*(3-4)*2 = (4/3)*(-1)*2 = -2.66666 we would have written (3.2) differently by using parentheses to change the order of evaluation: x = ((a/(b - c+d))*(e - a)*c (3.3)

How to generate the machine instructions

corresponding to a given expression? precedence rule + associative rule

3.4 (3/14)
Precedence
hierarchy and associative for C

3.4 Evaluation of Expressions (4/14)

Evaluating postfix expressions
The standard way of writing expressions is known as infix notation binary operator in-between its two operands Infix notation is not the one used by compilers to evaluate expressions Instead compilers typically use a parenthesis-free notation referred to as postfix

Postfix: no parentheses, no precedence

3.4 Evaluation of Expressions (5/14)

Evaluating postfix expressions is much simpler
than the evaluation of infix expressions:
There are no parentheses to consider. To evaluate an expression we make a single left-toright scan of it. We can evaluate an expression easily by using a stack Figure 3.14 shows this processing when the input is nine character string 6 2/3-4 2*+

3.4 Evaluation of Expressions (6/14)

Representation
We now consider the representation of both the stack and the expression

3.4 Evaluation of Expressions (7/14)

Get Token

3.4 (8/14)
Evaluation of
Postfix Expression

3.4 Evaluation of Expressions (9/14)

string: 6 2/3-4 2*+ we make a single left-to-right scan of it add the string with the operator

6 2 / 3 - 4 2 * +
2

not an operator, isoperator,anoperator, not an an operator, not is an operator, is operator, an operator, notan not is is operator, the answeranoperator,anend of string, put into into stack put into the stackelements put pop theinto the put into the stack theput two elements two stack pop stack pop pop elements two elements two the stackpop of the the stack of theand get answer of stack of stack the stack

1 0 top

4*2 4 3 2
6/2-3+4*2 6/2-3 6/2 6
STACK

6/2-3 + 4*2

now, top must +1 -1 -2

3.4 Evaluation of Expressions (10/14)

We can describe am algorithm for producing a postfix expression from an infix one as follows (1) Fully parenthesize expression a/b-c+d*e-a*c ((((a / b) - c) + (d * e)) - (a * c)) (2) All operators replace their corresponding right parentheses ((((a / b) - c) + (d * e)) - (a * c)) two passes * * / + (3)Delete all parentheses ab/c-de*+ac* The order of operands is the same in infix and postfix

3.4 Evaluation of Expressions (11/14)

Example 3.3 [Simple expression]: Simple expression a+b*c, which
yields abc*+ in postfix.
icp isp

12
13 0 12 13 13

Example 3.5 [Parenthesized expression]: The expression a*(b+c)*d,

which yields abc+*d* in postfix
icp 13 20 isp 13 0 0 12 12 match ) 13 13 13 13

12
19 13 0

3.4 Evaluation of Expressions (12/14)

Algorithm to convert from infix to postfix
Assumptions: operators: (, ), +, -, *, /, % operands: single digit integer or variable of one character 1. Operands are taken out immediately 2. Operators are taken out of the stack as long as their in-stack precedence (isp) is higher than or equal to the incoming precedence (icp) of the new operator 3. ( has low isp, and high icp
op ( Isp 0 Icp 20 ) 19 19 + 12 12 12 12 * 13 13 / 13 13 % 13 13 eos 0 0

precedence stack[MAX_STACK_SIZE]; /* isp and icp arrays -- index is value of precedence lparen, rparen, plus, minus, times, divide, mod, eos */ static int isp [ ] = {0, 19, 12, 12, 13, 13, 13, 0}; static int icp [ ] = {20, 19, 12, 12, 13, 13, 13, 0};

3.4 Evaluation of Expressions (13/14)

a * ( b + c ) / d
operand, operand, operand, operand, operator operator operator operator eos operator print out print out print out print out
pop the stack and printout push into the stack operator ( is 13 and the out until ( 20 the isp of),pop and print icp of * is 13 + 12 / 0 and the icp of * is 13 ( 2 1

(
* /
stack

output

a b c +

* d /

top
now, top must +1 -1

3.4 Evaluation of Expressions (14/14)

Complexity: (n)
The total time spent here is (n) as the number of tokens that get stacked and unstacked is linear in n where n is the number of tokens in the expression

3.5 MULTIPLE STACKS AND QUEUE (1/5)

Two stacks
m[0], m[1], , m[n-2], m[n-1]

bottommost stack 1 More than two stacks (n) memory is divided into n equal segments boundary[stack_no] 0 stack_no < MAX_STACKS top[stack_no] 0 stack_no < MAX_STACKS

bottommost stack 2

3.5 MULTIPLE STACKS AND QUEUE (2/5)

Initially, boundary[i]=top[i].
0 1 [ m/n ] 2[ m/n ] m-1

boundary[ 0] top[ 0]

boundary[1] top[ 1]

boundary[ 2] top[ 2]

boundary[n]

All stacks are empty and divided into roughly equal segments.

*Figure 3.18: Initial configuration for n stacks in memory [m]. (p.129)

3.5 MULTIPLE STACKS AND QUEUE (3/5)

a*(p.128) #define MEMORY_SIZE 100 /* size of memory */ #define MAX_STACK_SIZE 100 /* max number of stacks plus 1 */ /* global memory declaration */ element memory [MEMORY_SIZE]; int top [MAX_STACKS]; int boundary [MAX_STACKS]; int n; /* number of stacks entered by the user */ *(p.129) To divide the array into roughly equal segments : top[0] = boundary[0] = -1; for (i = 1; i < n; i++) top [i] =boundary [i] =(MEMORY_SIZE/n)*i; boundary [n] = MEMORY_SIZE-1;

3.5 MULTIPLE STACKS AND QUEUE (4/5)

*Program 3.12:Add an item to the stack stack-no (p.129)

void add (int i, element item) { /* add an item to the ith stack */ if (top [i] == boundary [i+1]) stack_full (i); may have unused storage memory [++top [i] ] = item; } *Program 3.13:Delete an item from the stack stack-no (p.130) element delete (int i) { /* remove top element from the ith stack */ if (top [i] == boundary [i]) return stack_empty (i); return memory [ top [i]--]; }

3.5 MULTIPLE STACKS AND QUEUE (5/5)

Find j, stack_no < j < n () such that top[j] < boundary[j+1] or, 0 j < stack_no ()

b[0]

t[0]

b[1] t[1]

b[i] t[i] t[i+1] b[i+1] b[i+2] meet b=boundary, t=top

t[j]

b[j+1] b[n]

*Figure 3.19: Configuration when stack i meets stack i+1, but the memory is not full (p.130)