Lecture 3
-
Upload
williamsock -
Category
Documents
-
view
6 -
download
0
description
Transcript of 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
The Stack (Common Examples)
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
The Stack (Common Examples)
Railway Shunting System
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
The Stack (Common Examples)
Railway Shunting System
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
The Stack (Common Examples)
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, Suffix, Prefix
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, Suffix, Prefix
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
Applications of Stackevaluating the following postfix expression.6 5 2 3 + 8 * + 3 + *
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
Applications of Stackevaluating the following postfix expression.6 5 2 3 + 8 * + 3 + *
5. Next a + is read so 40 and 5 are popped and 40 + 5 = 45 is pushed.
40
5
6
stack
45
6
stack
Applications of Stackevaluating the following postfix expression.6 5 2 3 + 8 * + 3 + *
6. Now 3 is pushed
45
6
stack
3
45
6
stack
Applications of Stackevaluating the following postfix expression.6 5 2 3 + 8 * + 3 + *
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
Applications of Stackevaluating the following postfix expression.6 5 2 3 + 8 * + 3 + *
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
Applications of StackConverting the following infix expression to postfix expression.a+b*c+(d*e+f)*g
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
Applications of StackConverting the following infix expression to postfix expression.a+b*c+(d*e+f)*g
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
Applications of StackConverting the following infix expression to postfix expression.a+b*c+(d*e+f)*g
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
Applications of StackConverting the following infix expression to postfix expression.a+b*c+(d*e+f)*g
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;
}
Continue on next slide…
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;
}
Continue on next slide…
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--];
}
Continue on next slide…
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