1. Stacks CS-240 Dick Steflik

2. Stacks Last In, First Out operation - LIFO As items are added they are chronologically ordered, items are removed in reverse chronological order (newest first)

3. Applications reversing the items in a list returning from a function/subroutine evaluation of postfix expressions converting infix expressions to postfix localization of parameters and variables in a function

4. Overflow and Underflow Stack overflow is the condition that arises when you attempt adding (pushing) an item onto an already full stack. –To avoid always check isFull( ) before adding Stack Underflow is the condition that arises when you attempt to remove (pop) an item from an already empty stack –To avoid always check isEmpty before popping

5. Normal methods constructor - create and initialize a stack object copy constructor - create a stack object that is a duplicate of another existing stack object (this method needed to insure correct value semantics) overloaded assignment operator - assign the value of an existing stack object (a) to another existing stack object (b) so that the result is that b is a duplicate of a (this method needed to insure correct value semantics) destructor - destroy a stack object by returning any of its dynamic storage back to the heap and setting its static elements to NULL or zero

6. Methods push - add an item (as the most recent) pop - delete the most recently added item pull - return the value of the most recently added item then delete the item peek - return the value of the most recently added item ifFull - return false/true depending if the stack is full; true if it is, false otherwise isEmpty - return false/true depending if the stack is empty; true if it is, false otherwise

7. Private data strategies use an array to hold items and use an int as an index for the array to indicate where the next item is to go same as above, but use a dynamic array use a struct to define a node and add nodes dynamically as they are needed; use one static pointer to a node at point at most recently added item(top of stack)

8. Static Static Implementation Class Stack { public: Stack( ){ top = 0; ) void push(int v) { data[top++] = v ; } void pop( ){ --top; } int pull( ) { return data[top--]; } int peek( ) { return data[top]; ) boolean isFull( ) { return top = = 20;} boolean isEmpty( ) { return top = = 0;} private: int data[20]; int top; }

9. Dynamic Array Implementation Class Stack { public: Stack( ){ size = 20 ; top = 0 ; data = new int[20] ; } Stack( int s ) { size = s ; top = 0 ; data = new int[s] ; ) void push(int v) { if (this.isFull( )) { temp = new int[size*2] ; size = size * 2; for (int j = 0 ; j < top; j++) temp[j] = data[j]; delete data ; data = temp; } data[top++] = v ; } int pop( ){ return data[--top]; } boolean isFull( ) { return top = = size;} boolean isEmpty( ) { return top = = 0;} private: int * data; int top; int size; }

10. Dynamic (nodal) implementation Class Stack { public: Stack( ){ top = NULL; ) ~Stack( ) { while (!this.isEmpty()) this.pop( ); } void push(int v) { node * temp = new node() ; temp -> data = v ; temp ->next = top ; top = temp; } int pull( ){ int value = top->data ; node * temp = top->next ; delete top ; top = temp; } void pop( ){ node * temp = top->next ; delete top ; top = temp; } boolean isEmpty( ) { return top = = NULL;} private: struct node { int data; node * next; } node * top; }