Data Structures using OOP C++ Lecture 9

Transcription

1 Stack A stack is an ordered group of homogeneous items or elements. The removal of existing items and the addition of new items can take place only at the top of the stack. The stack may be considered an ordered group of items because elements occur in particular sequence organized according to how long they ve been in the stack. The items that have been present in the stack the longest are at the bottom ; the most recent are the top. Because items are added and removed from only(one end) the top of the stack,the last element to be added is the first to be removed; Stack is a LIFO (Last In, First Out) structure. The accessing protocol for stack is summarized as follows: Both to retrieve elements and to store new elements, access only the top of the stack. Application of Stack Stacks are a fundamental data structure. They are used in many applications, including the following : -programming language systems typically use stack to keep track of operation calls.the main program calls operation A, which in turn calls operation B,which in turn calls operation C ;when function C terminates, control goes back to function B; and when function B terminates, control goes back to function A., -Internet Web browsers store the addresses of recently visited sites on a stack. Each time a user visits a new site, that site s address is pushed Asst. Lec. Zainab Mahmood Fadhil Page 1

2 onto the stack of addresses. The browser then allows the user to pop back to previously visited sites using the back button. -You can also use stacks to convert recursive algorithms into nonrecursive algorithms, especially recursive algorithms that are not tail recursive. -Text editors usually provide an undo mechanism that cancels recent editing operations and reverts to former states of a document. This undo operation can be accomplished by keeping text changes in a stack. Stack ADT specification Structure :Elements are added to and removed from the top of the stack. definitions (provided by user) : MAX_ITEMS :Maximum number of items that might be on the stack. ItemType : Data type of the items on the stack. Note : Because C++ arrays begin with the index 0, we need to distinguish between the value of stacktop and the array position indicated by stacktop. If stacktop is 0, the stack is empty; if stacktop is nonzero, then the stack is nonempty and the top element of the stack is given by stacktop - 1. Operations on stack(provided by the ADT) : Push :the operation that adds a new item to the top of stack Adding, or pushing, an element onto the stack is a two-step process. Recall that the value of stacktop indicates the number of elements in the stack, and Asst. Lec. Zainab Mahmood Fadhil Page 2

3 stacktop - 1 gives the position of the top element of the stack. Therefore, the push operation is as follows: 1. Store the newitem in the array component indicated by stacktop. 2. Increment stacktop. pop: the operation that removes the top element from the stack. To remove, or pop, an element from the stack, we simply decrement stacktop by 1. top: return a copy of the top element without removing it ;this operation is used to examine the item at the top of the stack. IsEmpty: Boolean operation to tell whether a stack contains any elements before we pop it. IsFull: Boolean operation to test whether a stack is full before pushing. Asst. Lec. Zainab Mahmood Fadhil Page 3

4 Stack as an ADT #include "stdafx.h" #include<iostream> #include<assert.h> using namespace std; typedef int elemtype; class stack { public: stack(); ~stack(){ delete[]elems ; // destructor bool IsEmpty() const { return top== 0 ; bool IsFull() const { return top == size ; void push (const elemtype &el); elemtype pop(); private: elemtype *elems; int top ; int size ; ; stack::stack() { size = 10; top = 0; elems = new elemtype[size] ; assert(elems) ; void stack::push(const elemtype &el) { assert(!isfull()); elems[top++] = el ; elemtype stack::pop() { assert(!isempty()); return elems[--top]; void main() { stack s ; Asst. Lec. Zainab Mahmood Fadhil Page 4

5 elemtype x; cout << "Enter stack elements : "; for(int k=0;k<10;k++) { cin>>x ; s.push(x); cout<<"stack status: " << (s.isempty()? "empty" : "Not empty"); cout <<"\nstack poped elements: "; for(k=0 ;k<10;k++) { elemtype x=s.pop(); cout<<x<<" " ; cout<<"\nstack status: " << (s.isempty()? "Empty" : "Not empty") << "\n"; Application of Stacks : Postfix Expressions Calculator The usual notation for writing arithmetic expressions is called infix notation, in which the operator is written between the operands. For example, in the expression a + b. In the late 1950s, the Australian philosopher and early computer scientist Charles L. Hamblin proposed a scheme in which operators follow the operands (postfix operators), resulting in the Reverse Polish notation. In fact, many compilers now first translate arithmetic expressions into some form of postfix notation and then translate this postfix expression into machine code. Infix Expression Equivalent Postfix Expression a +b ab + a + b *c ab c * + a * b +c ab * c + (a + b ) *c ab + c * (a _ b) * (c + d) a b _ c d + * (a + b) * (c _ d / e) +f ab + c d e / _ * f + the Asst. Lec. Zainab Mahmood Fadhil Page 5

6 Postfix expressions can be evaluated using the following algorithm: -Scan the expression from left to right. When an operator is found,back up to get the required number of operands, perform the operation, and continue. Consider the following postfix expression: * = 1. Read the first symbol, 6, which is a number. Push the number onto the stack. 2. Read the next symbol, 3, which is a number. Push the number onto the stack. 3. Read the next symbol, +, which is an operator. Because an operator requires two operands to be evaluated, pop the stack twice. Perform the operation and put the result back onto the stack. Perform the operation: op1 + op2 = = Read the next symbol, 2, which is a number. Push the number onto the stack. 5. Read the next symbol, *,which is an operator.because an operator requires two operands to be evaluated, pop the stack twice. Perform the operation and put the result back onto the stack. Perform the operation: op1 * op2 = 9 * 2 = 18. Push the result onto the stack. 6. Scan the next symbol, =, which is the equal sign, indicating the end of the expression. Therefore, print the result. The result of the expression is in the stack, so pop and print are as shown Asst. Lec. Zainab Mahmood Fadhil Page 6

7 stack after pushing 6 stack after pushing 3 stack after popping twice stack after pushing the result of op1+op2 Asst. Lec. Zainab Mahmood Fadhil Page 7

8 stack after pushing 2 stack after poping twice stack after pushing the result of op1*op2 stack after popping the element Asst. Lec. Zainab Mahmood Fadhil Page 8

9 Algorithm :To evaluate the expression -initialize empty stack. - while token remain in the input stream : -Read next token - If token is a number(operand) push it into the stack. - else if token is an operator pop two tokens off the stack,apply the Operator and push the result back onto the stack. -pop the answer off the stack. Evaluate : 54+8* Next token Stack Output None Empty None * 72 Done Empty 72 Asst. Lec. Zainab Mahmood Fadhil Page 9

10 Linked Implementation of Stacks Because an array size is fixed, in the array (linear) representation of a stack, only a fixed number of elements can be pushed onto the stack. If in a program the number of elements to be pushed exceeds the size of the array,the program may terminate in an error. We must overcome these problems. Fig :Empty Linked stack Fig: nonempty linked stack Asst. Lec. Zainab Mahmood Fadhil Page 10

11 Fig : Stack before the push operation fig: stack and newnode stack after the statement newnode -> link = stacktop Asst. Lec. Zainab Mahmood Fadhil Page 11

12 fig : stack after the statement stacktop= newnode Generic Linked Stack as ADT #include "stdafx.h" #include<iostream> #include<cassert> using namespace std; class stack; class Node { friend class stack<type>; private: Type data ; Node<Type> *link; Node(const Type &el); ; Node<Type> ::Node(const Type &el) {this->data =el ; this ->link=0 ; Asst. Lec. Zainab Mahmood Fadhil Page 12

13 class stack{ public : stack() {top= 0 ; ~stack(); bool isempty() const { return top== 0 ; stack& push(const Type &el); Type pop(); void print() const ; private : Node<Type> *top ; ; stack<type> ::~stack (){ Node<Type> *pnode ; while(top) { pnode = top ; top = top ->link ; pnode->link =0 ; delete pnode ; stack<type>& stack<type>::push(const Type &el) { Node<Type> *pnode= new Node<Type>(el); assert(pnode); pnode->link = top ; top= pnode ; return *this ; Type stack<type> ::pop (){ assert(!isempty()); Type temp = top->data ; Node<Type> *pnode = top ; top= top->link ; pnode->link=0 ; delete pnode; return temp; Asst. Lec. Zainab Mahmood Fadhil Page 13

14 void stack<type>::print() const{ Node<Type> *pnode = top ; while(pnode){ cout<<pnode->data <<" "; pnode= pnode->link ; cout<<endl; void main() { stack<int> s; // stack<char> t; // stack<double> d; int a; int n ; cout<<"enter the number of elements: " ; cin >> n ; cout<<"enter the elements: " <<endl; for (int i=0 ; i<n;i++) { cin>> a ; s.push(a); cout<<"current stack: "; s.print(); cout<<"the inverse of the stack is: " ; for( i=0;i<n;i++) cout<<s.pop()<<" " ; cout<<endl<<endl; Asst. Lec. Zainab Mahmood Fadhil Page 14

15 Reversing a Vector using a stack #include "stdafx.h" #include<iostream> #include<cassert> using namespace std; class stack; class Node { friend class stack<type>; private: Type data ; Node<Type> *link; Node(const Type &el); ; Node<Type> ::Node(const Type &el) {this->data =el ; this ->link=0 ; class stack{ public : stack() {top= 0 ; ~stack(); bool isempty() const { return top== 0 ; stack& push(const Type &el); Type pop(); void print() const ; private : Node<Type> *top ; ; stack<type> ::~stack (){ Node<Type> *pnode ; while(top) { pnode = top ; top = top ->link ; pnode->link =0 ; Asst. Lec. Zainab Mahmood Fadhil Page 15

16 delete pnode ; stack<type>& stack<type>::push(const Type &el) { Node<Type> *pnode= new Node<Type>(el); assert(pnode); pnode->link = top ; top= pnode ; return *this ; Type stack<type> ::pop (){ assert(!isempty()); Type temp = top->data ; Node<Type> *pnode = top ; top= top->link ; pnode->link=0 ; delete pnode; return temp; void stack<type>::print() const{ Node<Type> *pnode = top ; while(pnode){ cout<<pnode->data <<" "; pnode= pnode->link ; cout<<endl; void main() { const int n = 5; // Size of vector stack<char> s; char a[n]; cout<<"enter " << n <<" elements: " <<endl; for (int i=0 ; i<n;i++) { cin>> a[i] ; Asst. Lec. Zainab Mahmood Fadhil Page 16

17 s.push(a[i]); cout<<"current Vector: "; for( i=0;i<n;i++) cout<<a[i]<<" "; // Reversing the vector using stack for( i=0;i<n;i++) a[i] = s.pop(); cout<<"\nreversed Vector: "; for( i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl<<endl; Asst. Lec. Zainab Mahmood Fadhil Page 17