Stacks

1. Stacks

2. Stack ADT A stack is a data structure that holds a sequence of elements and stores and retrieves items in a last-in first-out manner (LIFO). This means that when a program retrieves an item from a stack, the last item inserted into the stack is the first one retrieved. Similarly, the first item inserted is the last one retrieved (FILO).

3. Last plate in, first plate out 5 4 3 2 first plate in, last plate out 1 Stack of Plates Stack ADT The stack is a common data structure for representing things that need to maintained in a particular order. For instance, when a function calls another function, which in turn calls a third function, it's important that the third function return back to the second function rather than the first.

4. Static and Dynamic Stacks There are two kinds of stack data structure - a) static, i.e. they have a fixed size, and are implemented asarrays. b) dynamic, i.e. they grow in size as needed, and implemented as linked lists.

5. push() and pop() A stack has two primary operations, called push and pop. a) The push operation causes a value to be stored (pushed) onto the stack. e.g. if we have an empty integer stack with maximum capacity of 3 items, we can perform the following 3 push operations - push(5); push(10); push(15);

6. push() and pop() The pop operation retrieves (removes) an itemfrom the stack. If we execute 3 consecutive pop operations on the stack as shown above, we get the following results -

7. Attempting the execution of an operation of an ADT may sometimes cause an error condition, called an exception. Exceptions are said to be “thrown” by an operation that cannot be executed. In the Stack ADT, operation pop cannot be performed if the stack is empty In the Stack ADT, operation push cannot be performed if the stack is full Attempting the execution of pop on an empty stack, or a push on a full stack, throws an EmptyStackException Exceptions

8. Therefore, in order to simulate a stack functionality, the following operations need to be implemented. Main stack operations: push(object o): inserts element o pop(): removes and returns the last inserted element Auxiliary stack operations: top(): returns a reference to the last inserted element without removing it size(): returns the number of elements stored isEmpty(): returns a Boolean value indicating whether no elements are stored Stack Operations

9. Applications of Stacks • Direct applications • Page-visited history in a Web browser • Undo sequence in a text editor • Saving local variables when one function calls another, and this one calls another, and so on. • Indirect applications • Auxiliary data structure for algorithms • Component of other data structures

10. bar PC = 1 m = 6 foo PC = 3 j = 5 k = 6 main PC = 2 i = 5 C++ Run-time Stack • The C++ run-time system keeps track of the chain of active functions with a stack • When a function is called, the run-time system pushes on the stack a frame containing • Local variables and return value • Program counter, keeping track of the statement being executed • When a function returns, its frame is popped from the stack and control is passed to the method on top of the stack main() { int i = 5; foo(i); } foo(int j) { int k; k = j+1; bar(k); } bar(int m) { … }

11. A simple way of implementing the Stack ADT uses an array We add elements from left to right A variable keeps track of the index of the top element … S 0 1 2 t Array-based Stack Algorithmsize() returnt +1 Algorithmpop() ifisEmpty()then throw EmptyStackException else tt 1 returnS[t +1]

12. … S 0 1 2 t Array-based Stack (cont.) • The array storing the stack elements may become full • A push operation will then throw a FullStackException • Limitation of the array-based implementation • Not intrinsic to the Stack ADT Algorithmpush(o) ift=S.length 1then throw FullStackException else tt +1 S[t] o

13. Performance and Limitations • Performance • Let n be the number of elements in the stack • The space used is O(n) • Each operation runs in time O(1) • Limitations • The maximum size of the stack must be defined a priori , and cannot be changed • Trying to push a new element into a full stack causes an implementation-specific exception

14. Writing a program that uses an STL stack

15. Using a Stack in a Program • Requirement • Reverse a phrase that is input by the user • Steps in the process of creating the program 1. Write a test 2. Write an algorithm 3. Write the program 4. Test the program • Run an automated test – one way to test your program

16. 1. Write a Test Reverse "Go dog" Reverse "Madam, I’m Adam"

17. 2. Write an Algorithm //ALGORITHM main() // Get the string s1 // Reverse the string // Print the reversed string

18. 2. Write an Algorithm //ALGORITHM main() // Get the string s1 // Use a stack to reverse the string // reverseString(s1) // Print the reversed string

19. 2. Write an Algorithm ALGORITHM reverseString(s1) Input: a string Output: the string reversed

20. 2. Write an Algorithm ALGORITHM reverseString(s1) Input: a string Output: the string reversed string s2 stack st for i = 0 to i = s1.length - 1 st.push(s1[i]) while not st.empty() s2 += st.top() st.pop() return s2

21. Implementing a Data Structureas a Class A Stack Example

22. Stack ADT

23. Add the curly braces, and remember the semicolon To begin… • Open a header file and name it “ArrayStack.h” • Write the keyword “class” followed by the name of the class class ArrayStack { };

24. Access specifier All member functions after “public:” are accessible by any client in your program wherever there is an object of this class. Step 1 – Declare Public Operations • Declare member functions for all the public operations that are called for by the ADT(See p. 157 for the stack ADT.) class ArrayStack { public: int size(); bool isEmpty(); void push( const char& c ); char& top(); void pop(); };

25. All members after “private:” are only accessible to the member functions of this class. Access specifier Information hiding Data members are always “private” so that the object’s client cannot change the data by accessing it directly. Data can be accessed only by using the “public” member functions. Step 2 – Declare Data Members • Next, decide how to hold the data that the data structure will contain. For example, you could put it into either an array or a linked list. class ArrayStack { private: int capacity;//Maximum capacity of the array char *pMyArray;//Pointer to an array public: int size(); bool isEmpty(); void push(const char& c); char& top(); void pop(); };

26. Step 3 – Define the Operations • Now, decide how to implement the operations class ArrayStack { private: int topIndex; int capacity; //Maximum capacity of the array char *pMyArray; //Pointer to an array public: int size(); bool isEmpty(); void push(const char& c); char& top() { return pMyArray[topIndex]; } void pop(); };

27. Step 4 – Add Exceptions etc. • Add robustness – use exceptions • Avoid memory problems • Implement a copy constructor • Implement operator=