Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Stacks Stack ADT A stack is a data structure that holds a sequence of elements and stores and retrieves items in a last-in firstout 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). Stack ADT 5 4 3 2 1 Last plate in, first plate out first plate in, last plate out Stack of Plates 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. Static and Dynamic Stacks There are two kinds of stack data structure a) static, i.e. they have a fixed size, and are implemented as arrays. b) dynamic, i.e. they grow in size as needed, and implemented as linked lists. 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); push() and pop() The pop operation retrieves (removes) an item from the stack. If we execute 3 consecutive pop operations on the stack as shown above, we get the following results - Exceptions 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 Stack Operations 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 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 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 runtime system pushes on the stack a frame containing main() { int i = 5; foo(i); } foo(int j) { – Local variables and return value int k; – Program counter, keeping track of k = j+1; the statement being executed bar(k); When a function returns, its frame is } popped from the stack and control is passed to the method on top of the bar(int m) { stack … } bar PC = 1 m=6 foo PC = 3 j=5 k=6 main PC = 2 i=5 Array-based Stack 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 Algorithm size() return t + 1 Algorithm pop() if isEmpty() then throw EmptyStackException else tt1 return S[t + 1] … S 0 1 2 t Array-based Stack (cont.) The array storing the Algorithm push(o) stack elements may become full if t = S.length 1 then A push operation will then throw FullStackException throw a else FullStackException – – Limitation of the arraybased implementation Not intrinsic to the Stack ADT tt+1 S[t] o … S 0 1 2 t 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 Writing a program that uses an STL stack 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 1. Write a Test Reverse "Go dog" Reverse "Madam, I’m Adam" 2. Write an Algorithm //ALGORITHM main() // Get the string s1 // Reverse the string // Print the reversed string 2. Write an Algorithm //ALGORITHM main() // Get the string s1 // Use a stack to reverse the string // reverseString(s1) // Print the reversed string 2. Write an Algorithm ALGORITHM reverseString(s1) Input: a string Output: the string reversed 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 Implementing a Data Structure as a Class A Stack Example Stack ADT int size() Return the number of elements in the stack bool isEmpty() Indicate whether the stack is empty void push( Object element ) Insert element at the top of the stack Object top() Return the top element on the stack without removing it; an error occurs if the stack is empty. Object pop() Remove and return the top element on the stack; an error occurs if the stack is empty To begin… Open a header file and name it “ArrayStack.h” Write the keyword “class” followed by the name of the class class ArrayStack { }; Add the curly braces, and remember the semicolon 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: Access specifier int size(); bool isEmpty(); void push( const char& c ); char& top(); void pop(); }; All member functions after “public:” are accessible by any client in your program wherever there is an object of this class. 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. All members after “private:” are only Access specifier accessible to the member functions of this class. class ArrayStack { private: int capacity;//Maximum capacity of the array char *pMyArray;//Pointer to an array Information hiding public: int size(); Data members are always “private” so that the object’s client cannot change bool isEmpty(); void push(const char& c); the data by accessing it directly. Data can be accessed only by using the char& top(); “public” member functions. void pop(); }; 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(); }; Step 4 – Add Exceptions etc. Add robustness – use exceptions Avoid memory problems – – Implement a copy constructor Implement operator=