1. Data Structures Using C++1 Chapter 7 Stacks

2. Data Structures Using C++2 Chapter Objectives Learn about stacks Examine various stack operations Learn how to implement a stack as an array Learn how to implement a stack as a linked list Discover stack applications Learn to use a stack to remove recursion Become aware of the STL class stack

3. Data Structures Using C++3 Stacks Definition: list of homogeneous elements, wherein the addition and deletion of elements occur only at one end, called the top of the stack Last In First Out (LIFO) data structure Used to implement function calls Used to convert recursive algorithms (especially not tail recursive) into nonrecursive algorithms

4. Data Structures Using C++4 Various Types of Stacks

5. Data Structures Using C++5 LIFO Last In First Out (LIFO) data structure –Top element of stack is last element to be added to stack –Elements added and removed from one end (top) –Item added last are removed first

6. Data Structures Using C++6 Empty Stack

7. Data Structures Using C++7 Stack Operations

8. Data Structures Using C++8 Basic Operations on a Stack initializeStack: Initializes the stack to an empty state destroyStack: Removes all the elements from the stack, leaving the stack empty isEmptyStack: Checks whether the stack is empty. If empty, it returns true; otherwise, it returns false

9. Data Structures Using C++9 Basic Operations on a Stack isFullStack: Checks whether the stack is full. If full, it returns true; otherwise, it returns false push: –Add new element to the top of the stack –The input consists of the stack and the new element. –Prior to this operation, the stack must exist and must not be full

10. Data Structures Using C++10 Basic Operations on a Stack top: Returns the top element of the stack. Prior to this operation, the stack must exist and must not be empty. pop: Removes the top element of the stack. Prior to this operation, the stack must exist and must not be empty.

11. Data Structures Using C++11 Example of a Stack

12. Data Structures Using C++12 Empty Stack

13. Data Structures Using C++13 initializeStack and destroyStack template void stackType ::initializeStack() { stackTop = 0; }//end initializeStack template void stackType ::destroyStack() { stackTop = 0; }//end destroyStack

14. Data Structures Using C++14 emptyStack and fullStack template bool stackType ::isEmptyStack() { return(stackTop == 0); }//end isEmptyStack template bool stackType ::isFullStack() { return(stackTop == maxStackSize); }//end isFullStack

15. Data Structures Using C++15 Push

16. Data Structures Using C++16 Push template void stackType ::push(const Type& newItem) { if(!isFullStack()) { list[stackTop] = newItem; //add newItem at the top //of the stack stackTop++; //increment stackTop } else cerr<<"Cannot add to a full stack."<<endl; }//end push

17. Data Structures Using C++17 Return Top Element template Type stackType ::top() { assert(stackTop != 0); //if the stack is empty, //terminate the program return list[stackTop - 1]; //return the element of the //stack indicated by //stackTop - 1 }//end top

18. Data Structures Using C++18 Pop template void stackType ::pop() { if(!isEmptyStack()) stackTop--; //decrement stackTop else cerr<<"Cannot remove from an empty stack."<<endl; }//end pop

19. Data Structures Using C++19 Pop

20. Data Structures Using C++20 copyStack template void stackType ::copyStack(const stackType & otherStack) { delete [] list; maxStackSize = otherStack.maxStackSize; stackTop = otherStack.stackTop; list = new Type[maxStackSize]; assert(list != NULL); //copy otherStack into this stack for(int j = 0; j < stackTop; j++) list[j] = otherStack.list[j]; }//end copyStack

21. Data Structures Using C++21 Copy Constructor template stackType ::stackType(const stackType & otherStack) { list = NULL; copyStack(otherStack); }//end copy constructor

22. Data Structures Using C++22 Overloading the Assignment Operator (=) template const stackType & stackType ::operator= (const stackType & otherStack) { if(this != &otherStack) //avoid self-copy copyStack(otherStack); return *this; }//end operator=

23. Data Structures Using C++23 Time-Complexity of Operations of class stackType

24. Data Structures Using C++24 Stack Header File //Header file: myStack.h #ifndef H_StackType #define H_StackType #include using namespace std; //Place the definition of the class template stackType, as given //previously in this chapter, here. //Place the definitions of the member functions, as discussed in //this chapter, here. #endif

25. Data Structures Using C++25 Programming Example: Highest GPA InputThe program reads an input file consisting of each student’s GPA, followed by the student’s name. Sample data is: 3.8 Lisa 3.6 John 3.9 Susan 3.7 Kathy 3.4 Jason 3.9 David 3.4 Jack

26. Data Structures Using C++26 Programming Example: Highest GPA (Algorithm) 1.Declare the variables. 2.Open the input file. 3.If the input file does not exist, exit the program. 4.Set the output of the floating-point numbers to a fixed decimal format with a decimal point and trailing zeroes. Also, set the precision to two decimal places. 5.Read the GPA and student name. 6. highestGPA = GPA; 7.Initialize the stack.

27. Data Structures Using C++27 Programming Example: Highest GPA (Algorithm) 8.while (not end of file) { 8.1 if (GPA > highestGPA) { 8.1.1 destroyStack(stack); 8.1.2 push(stack, student name); 8.1.3 highestGPA = GPA; } 8.2 else if(GPA is equal to highestGPA) push(stack, student name); 8.3 Read the GPA and student name; }

28. Data Structures Using C++28 Programming Example: Highest GPA (Algorithm) 9.Output the highest GPA. 10.Output the names of the students having the highest GPA.

29. Data Structures Using C++29 Programming Example: Highest GPA (Sample Run) Input File (Ch7_HighestGPAData.txt) 3.4 Holt 3.2 Bolt 2.5 Colt 3.4 Tom 3.8 Ron 3.8 Mickey 3.6 Pluto 3.5 Donald 3.8 Cindy 3.7 Dome 3.9 Andy 3.8 Fox 3.9 Minnie 2.7 Goofy 3.9 Doc 3.4 Danny

30. Data Structures Using C++30 Programming Example: Highest GPA (Sample Run) Output Highest GPA = 3.90 The students holding the highest GPA are: Doc Minnie Andy

31. Data Structures Using C++31 Empty and Nonempty Linked Stack Empty linked stackNonempty linked stack

32. Data Structures Using C++32 Default Constructor template //default constructor linkedStackType ::linkedStackType() { stackTop = NULL; }

33. Data Structures Using C++33 Destroy Stack template void linkedStackType ::destroyStack() { nodeType *temp; //pointer to delete the node while(stackTop != NULL) //while there are elements //in the stack { temp = stackTop; //set temp to point to //the current node stackTop = stackTop->link; //advance stackTop //to the next node delete temp; //deallocate the memory //occupied by temp } }//end destroyStack

34. Data Structures Using C++34 initializeStack and isStackEmpty template void linkedStackType :: initializeStack() { destroyStack(); } template bool linkedStackType ::isEmptyStack() { return(stackTop == NULL); } template bool linkedStackType ::isFullStack() { return false;

35. Data Structures Using C++35 Push Stack before the push operation Stack and newNode

36. Data Structures Using C++36 Push Stack after the statement newNode->link = stackTop; executes Stack after the statement stackTop = newNode; executes

37. Data Structures Using C++37 Return Top Element template Type linkedStackType ::top() { assert(stackTop != NULL); //if the stack is empty, //terminate the program return stackTop->info; //return the top element }//end top

38. Data Structures Using C++38 Pop Stack before the pop operation

39. Data Structures Using C++39 Pop Stack after the statements temp = stackTop ; and stackTop = stackTop->link; execute Stack after the statement delete temp; executes

40. Data Structures Using C++40 Application of Stacks: Postfix Expression Calculator

41. Data Structures Using C++41 Application of Stacks: Postfix Expression Calculator Stack after pushing 6 Stack after pushing 3 Stack after retrieving the top two elements and popping twice Stack after pushing the result of op1 + op2, which is 9

42. Data Structures Using C++42 Application of Stacks: Postfix Expression Calculator Stack after pushing 2 Stack after retrieving the top two elements and popping twice Stack after pushing the result of op1 * op2, which is 18 Stack after popping the element

43. Data Structures Using C++43 Postfix Expression Calculator (Main Algorithm)

44. Data Structures Using C++44 Nonrecursive Algorithm to reverse linked list current = first; while(current != NULL) { stack.push(current); current = current->link; } llistType, *newfirst = stack.pop(); current = newfirst; while (!stack.empty()) current->link = stack.pop(); current->link = NULL;

45. Data Structures Using C++45 List After Execution of Statement current = first;

46. Data Structures Using C++46 Repeated Execution of: stack.push(current); current = current->link;

47. Data Structures Using C++47 STL class stack (Stack Container Adapter) Standard Template Library (STL) provides a class to implement a stack in a program Name of the class defining a stack is “stack” Name of the header file containing the definition of the class stack is “stack”

48. Data Structures Using C++48 Operations on a stack Object