Lecture 3

Linear Data Structures

“Stack”

Lecture # 3

Topics Covered in This Lecture

Stack– Concepts– Common examples– Common operations– Array implementation

Applications of stack– Reversing the string– Balancing symbols– Postfix expression evaluation– Translating infix expression to postfix expression

Array dynamic stack

Linear Data Structures

There are two ways of storing data structures in the computer’s memory. The first of these storage-allocation methods, which takes advantage of the one-dimensional property of the computer’s memory, is called sequential allocation. The second allocation method, which is based on the storage of the address or location of each element in the list, is known as linked allocation.

Stack

A stack is a special case of a list. Rather than being allowed to insert a new item into the list at any place, additions to a stack are restricted to one end identified as the top of the stack. Deletions from the stack are also restricted to the top of the stack. Usually, only the item at the top of the stack is accessible to someone using the stack ADT. A stack is often referred to as a FILO (First In Last Out) or LIFO (Last In First Out) list. The stack only allows addition and removal from the top so the order of removal is the opposite to that of insertion.

Stack

A stack is a list with the restriction that Inserts and Removes can be performed in only one position, namely the end of the list, called the top.Fundamental operations on a stack are

Push - equivalent to an insertPop - removes the most recently inserted

element Pop from an empty stack is generally considered an error in the stack ADT.Running out of space when performing a push is an implementation error but not an ADT error.

The Stack (Common Examples)

Plates on a cafeteria serving line.– This arrangement of trays is supported by a spring

so that a person desiring a tray finds that only one is available at the surface of the tray counter.

Top tray of pileStacked trays

Spring


Railway Shunting System

Suppose that we have four railway cars (DCBA) sitting on the left-hand (input) track, as shown in the fig.We are required to rearrange these cars so that their order is (ACDB) that of the right-hand (output) track in the fig.We will restrict our shunting system so that it typifies a stack.Therefore, once a railway car has left the left-hand (input) track for the stack, it cannot return.

Likewise, once a railway car has left the stack for the right hand (output) track, it cannot return to the stack.

D C B A A C D B

Before After

Stack

Input



Clearly, at any given time, the only car that can move onto the stack is the one at the front of the input stream.

The only car that can move to the output stream is the one at the top of the stack.

D C B A A C D B

Before After

Stack

Input



Operation Input Stack OutputInitial DCBAPush(A) DCB APush(B) DC B

APop() DC A BPush( C) D C B

APush(D) D B

CA

Pop() C DBA

Pop() A CDBPop() ACDB

D C B A A C D B

Before After

Stack

Input


A list of recently visited URLs for a web browser’s “Back” and “Forward” buttons.The “undo” mechanisms in word processors.

Stack

Insertion

Deletion Bottom Top

The Stack

Assume an initially empty stack and following sequence of insertions and deletions:

Stack

The five common operations which are associated with a stack are: – Initialize: Initializes stack; that is, prepare it for use as a

stack.– Push: Inserts an element on top of stack and returns the

new stack.– Pop: Removes the top element from the stack and return the

updated stack.– IsEmpty: Returns “true” as the function result if stack

contains no element, or otherwise returns “false”.– TopValue: returns the top element of stack as the function

result.

Stack (stack.h)

#include<iostream.h>const int MAX = 100; template <class Type>class Stack {private:

Type data[MAX]; // stack: array of any typeint top; // number of top of stack

public: Stack(); // constructorvoid push(Type); // put number on stack

Type pop(); // take number off stackbool isEmpty();//checks if stack is empty or notType topValue();//gives top value of stack

};

Stack (stack.h)

template <class Type>Stack<Type>::Stack(){ top = -1;}

// Push a value onto the stacktemplate <class Type>void Stack<Type>::push(Type item){

if (top == MAX-1) cerr << "Stack Full!\n";

else data[++top] = item;

}

Stack (stack.h)

// Pop a value off of the stacktemplate <class Type>Type Stack<Type>::pop(){

if (top == -1) {

cerr << "Stack Empty!\n"; return 0;

}else

return data[top--];}

Stack (stack.h)// Check whether the stack is emptytemplate <class Type>bool Stack<Type>::isEmpty(){

if (top == -1) return true;

else return false;

}

// Provide the top value of the stacktemplate <class Type>Type Stack<Type>::topValue(){

return data[top];}

Stack (driver.cpp)

#include<iostream.h>#include"stack.h"void main(){// s1 is object of class Stack<float>Stack<float> s1;// push 2 floats, pop 2 floatss1.push(11.1);s1.push(22.2);s1.push(33.3);cout << "1: " << s1.pop() << endl;cout << "2: " << s1.pop() << endl;while (!s1.isEmpty())

{cout <<"from loop: " << s1.pop() <<endl;}

Output

1: 33.3

2: 22.2

from loop: 11.1

Stack (driver.cpp)

// s2 is object of class Stack<int>

Stack<int> s2;

// push 2 ints, pop 2 ints

s2.push(123);

s2.push(456);

cout << "1: " << s2.pop() << endl;

cout << "2: " << s2.pop() << endl;

} // End of program

Output

1: 456

2: 123

Polish Notation

a – b / c + d * e

Precedence?

1. b/c

2. d*e

3. a – a1 /a1 = b/c /

4. t2 + a2 / t2 = a – b/c / /a2 = d*e/

Infix, Suffix, Prefix

Infix = a * b + c((a*b) +c) Priority: 1. a * b2. a1 + c / a1 = a * b / Prefix = * a b , +a1 c+*abcSuffix = ab* , a1c+ab*c+


infix = a- b * c / d + e / f suffix =a – bc* / d + e / f

a – bc*d/ + e / f a – bc*d/ + ef/ abc*d/- + ef/ abc*d/-ef/+

prefix =a - *bc / d + e / f a - /*bcd + e / f a - /*bcd + /ef -a/*bcd + /ef +-a/*bcd/ef


Infix:

a+b*c–d/f+e

Suffix:

abc*+df/-e+

Prefix:

+-+a*bc/dfe

Applications of Stack

Reversing the string

– push each character on to a stack as it is read.

– When the line is finished, we then pop characters off the stack, and they will come off in the reverse order.

Applications of StackReversing the stringvoid ReverseRead(void){ //using static Stack class of Lecture#3

Stack<char> stack;//The Stack ‘stack’ is createdchar item;cin>>item;while (!stack.isFull()&&item!='$')//type in $ from keyboard to stop input

{ stack.push(item); // push each character onto the stack cin>>item;

}while(!stack.isEmpty() ){ item=stack.pop ();//Pop an element from stack

cout<<item;}

}

Applications of StackBalancing SymbolsCompilers use a program that checks whether every symbol (like braces, parenthesis, brackets, etc) in a program is balanced.

The simple algorithm for this purpose is:

1. Make an empty stack.

2. Read the characters until end of file.

3. If the character is an open any thing, push it onto the stack.

4. If it is a close any thing, then

if the stack is empty report an error.

Otherwise Pop the Stack.

If the popped symbol is not the corresponding opening symbol, then report an error.

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

Applications of StackPostfix Expression Evaluation

– When a number is seen, it is pushed onto the stack

– When an operator is seen, then pop two elements from stack and push the result onto the stack.

Now we evaluate the following postfix expression.6 5 2 3 + 8 * + 3 + *

1. The first four are placed on the stack. The resulting stack is

3

2

5

6

stack

Applications of Stack

evaluating the following postfix expression.6 5 2 3 + 8 * + 3 + *

3

2

5

6

stack2. Next a + is read, so 3 and 2 are popped from the stack and their sum 5 is

pushed. 5

5

6

stack

Applications of Stackevaluating the following postfix expression.6 5 2 3 + 8 * + 3 + *

5

5

6

stack3. Next 8 is read and pushed. 8

5

5

6

stack


4. Next a * is seen so 8 and 5 are popped as 8 * 5 = 40 is pushed

40

5

6

stack

8

5

5

6

stack


5. Next a + is read so 40 and 5 are popped and 40 + 5 = 45 is pushed.

40

5

6

stack

45

6

stack


6. Now 3 is pushed

45

6

stack

3

45

6

stack


7. Next symbol is + so pops 3 and 45 and pushes 45 + 3 = 48, so push 48 in stack.

3

45

6

stack

48

6

stack


7. Finally a * is seen and 48 and 6 are popped, the result 6 * 48 = 288 is pushed.

288

stack

48

6

stack

8. As there is no input, so pop the stack and we get the result.

Applications of StackTranslating infix expressions to postfix expression

– When an operand is read, it is immediately placed onto the output.

– When an operator or left parenthesis comes then save it in the stack initially stack is empty.

– If we see a right parenthesis, then we pop the stack, writing symbols until we encounter a (corresponding) left parenthesis, which is popped but not output.

– If we see any other symbol (‘+’, ‘*’, ‘(‘, etc) then we pop entries form the stack until we find an entry of lower priority. One exception is that we never remove a ‘(‘ from the stack except when processing a ‘)’.

– When the popping is done, we push the operand onto the stack.

– Finally, if we read the end of input, we pop the stack until it is empty, writing symbols onto the output.

Applications of StackTranslating infix expressions to postfix expression

Convert the following infix expression to postfix expression.a+b*c+(d*e+f)*g

1. First the symbol a is read, so it is passed through to the output a

output2. Then + is read and pushed onto the stack.

+

stack

4. Next a * is read. The top entry on the operator stack has lower precedence than *, so nothing is output and * is put on the .

3. Next b is read and passed through to the output. ab

output *

+

stack

Applications of StackConverting the following infix expression to postfix expression.a+b*c+(d*e+f)*g

5. Next, c is read and output.

6. The next symbol is a +. Checking the stack, we find that priority of stack top symbol * is higher than + . So we pop a * and place it on the output, Pop the other +, which is not of lower but equal priority, and then push +.

+

stack

abc*+

output

*

+

stack

abc

output


7. The next symbol read is an ‘(‘, which, being of highest precedence, is placed on the stack.

(

+

stack8. Then d is read and output. abc*+d

output

Applications of StackConverting the following infix expression to postfix expression.a+b*c+(d*e+f)*g9. We continue by reading a *. Since open parenthesis do not get removed except

when a closed parenthesis is being processed, there is no output and we push * in stack

*

(

+

stack10. Next, e is read and output.

abc*+de

output


11. The next symbol read is a +, since priority of stack top value is higher so we pop * and push +.

abc*+de*

output

+

(

+

stack

12. Now we read f and output f.abc*+de*f

output


13. Now we read a ‘)’, so the stack is emptied back to the ‘(‘, we output a +.

14. We read a * next; it is pushed onto the stack.

abc*+de*f+

output+

stack

*

+

stack15. Now, g is read and output. abc*+de*f+g

output


16. The input is now empty, so pop output symbols from the stack until it is empty.

abc*+de*f+g*+

outputstack

*

+

stack

Array Dynamic Stack

//stack.h#include<iostream.h>template <class Element_Type>class Stack{

private:/* This variable is used to indicate stack size*/unsigned int size;/* This variable is used to indicate top of the stack */int top;/* This pointer points to the array which behaves as stack, the space for this

array is allocated dynamically */Element_Type *data;

public:

Continue on next slide…

Array Dynamic Stack

//This constructor creates a stack.Stack(unsigned int max_Size)

{size = max_Size;top = -1;data = new Element_Type[max_Size];

}/* This Destructor frees the dynamically allocated space to the array */~Stack()

{delete[] data;

}


Array Dynamic Stack

/*This function returns TRUE if the stack is full, FALSE otherwise.*/bool isFull()

{ if (top == size-1)return true;

elsereturn false;

}/*This function returns TRUE if the stack is empty, FALSE otherwise.*/bool isEmpty()

{ if(top == -1)return true;

elsereturn false;

}


Array Dynamic Stack

// If stack is not full then push an element x in itvoid push(Element_Type x)

{ if(isFull())cout<<"stack is full";

elsedata[++top] = x;

}//if Stack is not empty then pop an element form itElement_Type pop()

{ if(isEmpty())cout<<"stack is empty";

elsereturn data[top--];

}


Array Dynamic Stack

// This function makes the stack empty void makeEmpty(){ top = -1;}

/* This function returns the top element of stack */Element_Type topValue(){if(isEmpty())

cout<<"stack is emepty";else

return data[top];}

};//end of Stack class

Array Dynamic Stack//driver.cpp

#include<iostream.h>#include"stack.h"void main(){int s;cout<<"Enter the stack size: ";cin>>s;Stack<char> stack(s); //size of this stack is decided at runtimestack.push('a');stack.push('b');stack.push('c');cout<<"1: "<<stack.pop()<<endl;cout<<"2: "<<stack.pop()<<endl;cout<<"3: "<<stack.pop()<<endl;}

Output

Enter the stack size: 3

1: c

2: b

3: a

Lecture 3

Documents

Transcript of Lecture 3