Download presentation

1
**The unorganized person’s data structure**

Stacks The unorganized person’s data structure stacks

2
**Stack characteristics**

Entries are ordered in terms of access -- both insertion and removal take place at same spot (top of stack) Specialized type of container class; defining characteristic is insertion/removal order LIFO = last in, first out; entries are removed in reverse order of insertion stacks

3
**Stack operations Push -- insert item on stack**

Pop -- remove item from stack Peek -- examine, but don’t remove item stacks

4
Stack operations Important to know if stack is empty -- attempt to remove an item from an empty stack is an underflow error Depending on implementation, may be necessary to check if stack is full -- attempt to add item to a full stack is an overflow error stacks

5
**Implementation of Stack ADT**

Stacks can be array based (static or dynamic) or linked list based Invariant for static array implementation: The number of items stored in the stack is found in member variable used Items are stored in member variable data, a static array with the stack bottom at data[0] and the stack top at data[used - 1] stacks

6
**Stack class -- static array version**

template <class Item> class Stack { public: enum {CAPACITY = 64}; Stack ( ); // default constructor Item pop ( ); // removes top Item Item peek ( ) const; // reveals top Item . . . stacks

7
Stack ADT continued void push (const Item & entry); // adds Item to stack size_t size ( ) const {return used;} bool is_empty ( ) const {return used == 0;} private: Item data[CAPACITY]; // the stack itself size_t used; // # of items stored in stack }; stacks

8
**Stack function implementations: constructor**

// Postcondition: empty stack is created template <class Item> Stack<Item>::Stack( ) { used = 0; } stacks

9
**Pop function // Precondition: stack is not empty**

// Postcondition: top item is removed template <class Item> Item Stack<Item>::pop ( ) { assert (!is_empty( )); used--; return data[used]; } stacks

10
**Peek function // Precondition: stack is not empty**

// Postcondition: top item is revealed template <class Item> Item Stack<Item>::peek ( ) const { assert (!is_empty( )); return data[used - 1]; } stacks

11
**Push function // Precondition: stack is not full**

// Postcondition: an item is inserted on stack template <class Item> void Stack<Item>::push(const Item& entry) { assert (size() < CAPACITY); data[used] = entry; used++; } stacks

12
**Stack application examples**

Compilers use stacks for a variety of purposes: syntax analysis: matching brackets, parentheses, etc. activation records: structures associated with functions, keeping track of local variables, return address, etc. stacks

13
**Example application: balanced parentheses**

Pseudocode algorithm: scan string left to right if ‘(‘ is encountered, push on stack if ‘)’ is encountered, and stack is not empty, pop one ‘(‘ -- if stack is empty, expression is unbalanced if stack is empty when entire string has been scanned and analyzed, expression is balanced stacks

14
**A program to test for balanced parentheses**

int main( ) { String user_input; // uses String data type defined in ch. 4 - based on array cout << "Type a string with some parentheses and no white space:\n"; cin >> user_input; if (balanced_parentheses(user_input)) cout << "Those parentheses are balanced.\n"; else cout << "Those parentheses are not balanced.\n"; cout << "That ends this balancing act.\n"; return EXIT_SUCCESS; } stacks

15
**balanced_parentheses function**

bool balanced_parentheses(const String& expression) // Library facilities used: assert.h, stack1.h, stdlib.h, mystring.h. { // Meaningful names for constants const char LEFT_PARENTHESIS = '('; const char RIGHT_PARENTHESIS = ')'; Stack<char> store; // Stack to store the left parentheses as they occur size_t i; // An index into the String char next; // The next character from the String char discard; // A char popped off the stack and thrown away bool failed = false; // Becomes true if a needed parenthesis is not found . . . stacks

16
**balanced_parentheses continued**

for (i = 0; !failed && (i < expression.length( )); i++) { next = expression[i]; if (next == LEFT_PARENTHESIS) if (store.size( ) < store.CAPACITY); store.push(next); } else if ((next == RIGHT_PARENTHESIS) && (!store.is_empty( ))) discard = store.pop( ); else if ((next == RIGHT_PARENTHESIS) && (store.is_empty( ))) failed = true; return (store.is_empty( ) && !failed); stacks

17
**Stack ADT as linked list**

Can make use of toolkit functions to simplify task Stack can grow & shrink as needed to accommodate data -- no fixed size Invariant: stack items are stored in a linked list member variable top is head pointer to list stacks

18
**Class definition for new Stack**

template <class Item> class Stack { public: Stack( ) { top = NULL; } Stack(const Stack& source); ~Stack( ) { list_clear(top); } ... stacks

19
**Stack definition continued**

void push(const Item& entry); Item pop( ); void operator =(const Stack& source); size_t size( ) const {return list_length(top);} bool is_empty( ) const {return top == NULL;} Item peek( ) const; private: Node<Item> *top; // Points to top of stack }; stacks

20
**Push function template <class Item>**

void Stack<Item>::push(const Item& entry) { list_head_insert(top, entry); } stacks

21
**Pop function template <class Item>**

Item Stack<Item>::pop( ) { assert(!is_empty( )); Item answer = top->data; list_head_remove(top); return answer; } stacks

22
**Peek function template <class Item>**

Item Stack<Item>::peek( ) const { assert(!is_empty( )); return top->data; } stacks

23
**Copy constructor template <class Item>**

Stack<Item>::Stack(const Stack<Item>& source) { list_copy(source.top, top); } stacks

24
**Assignment operator template <class Item>**

void Stack<Item>::operator =(const Stack<Item>& source) { if (source.top== top) // Handle self-assignment return; list_clear(top); list_copy(source.top, top); } stacks

25
**A stack-based calculator**

Input to program is a fully-parenthesized expression -- examples: ((5.3 * 1.2) / 3.1) (4 - 3) Two stacks are used -- one for operators, one for operands Right parenthesis is signal to pop the stacks and evaluate the expression stacks

26
**Algorithm for expression evaluation**

Evaluate leftmost, innermost expression; continue evaluating, left to right Read each part of expression Push numbers on operand stack, operators on operator stack When right parenthesis is encountered, pop the stacks, evaluate, and push result on operand stack stacks

27
**Code for stack calculator**

int main( ) { double answer; cout << "Type a fully parenthesized arithmetic expression:" << endl; answer = read_and_evaluate(cin); cout << "That evaluates to " << answer << endl; return EXIT_SUCCESS; } stacks

28
**Code for stack calculator**

double read_and_evaluate(istream& ins) { const char DECIMAL = '.'; const char RIGHT_PARENTHESIS = ')'; Stack<double> numbers; Stack<char> operations; double number; char symbol; ... stacks

29
**Code for stack calculator**

while (!ins.eof( ) && ins.peek( ) != '\n') { if (isdigit(ins.peek( )) || (ins.peek( ) == DECIMAL)) ins >> number; numbers.push(number); } … stacks

30
**Code for stack calculator**

else if (strchr("+-*/", ins.peek( )) != NULL) { ins >> symbol; operations.push(symbol); } stacks

31
**Code for stack calculator**

else if (ins.peek( ) == RIGHT_PARENTHESIS) { cin.ignore( ); evaluate_stack_tops(numbers, operations); } else } // end of while loop return numbers.pop( ); stacks

32
**Code for stack calculator**

void evaluate_stack_tops(Stack<double>& numbers, Stack<char>& operations) { double operand1, operand2; operand2 = numbers.pop( ); operand1 = numbers.pop( ); ... stacks

33
**Code for stack calculator**

switch (operations.pop( )) { case '+': numbers.push(operand1 + operand2); break; case '-': numbers.push(operand1 - operand2); ... stacks

34
**Code for stack calculator**

4/12/2017 Code for stack calculator case '*': numbers.push(operand1 * operand2); break; case '/': numbers.push(operand1 / operand2); } // end switch statement } // end function stacks stacks

Similar presentations

Presentation is loading. Please wait....

OK

Stacks1 Stacks The unorganized person’s data structure.

Stacks1 Stacks The unorganized person’s data structure.

© 2018 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on statistics in maths what does product Ppt on stock market in india Ppt on review writing worksheets Ppt on polynomials and coordinate geometry pictures Ppt on aerobics dance Ppt on bluetooth and wifi Ppt on coffee shop business plan Ppt on nanocomposites A ppt on air pollution Ppt on drugs and alcohol abuse