Date post: | 28-Dec-2015 |
Category: |
Documents |
Upload: | peter-hill |
View: | 225 times |
Download: | 0 times |
Stacks
Stacks 2
What Are Stacks ?
PUSHPUSH POPPOP
00
MAXMAX
Underflow
Overflow
-1-1
Stacks 3
The Stack ADTThe Stack ADT stores arbitrary objectsInsertions and deletions follow the last-in first-out schemeThink of a spring-loaded plate dispenserMain stack operations:
push(object o): inserts element o
pop(): removes and returns the last inserted element
Auxiliary stack operations:
getTop(): 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
Stacks 4
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
Stacks 5
Array-based StackA simple way of implementing the Stack ADT uses an arrayWe add elements from left to rightA variable keeps track of the index of the top element
S0 1 2 t
…
Algorithm size()return t + 1
Algorithm pop()if isEmpty() then
error (Empty Stack) else
t t 1return S[t + 1]
Stacks 6
Array-based Stack (cont.)The array storing the stack elements may become fullA push operation will then throw a Full Stack Error condition
Limitation of the array-based implementation
Not intrinsic to the Stack ADT
S0 1 2 t
…
Algorithm push(o)if (t = S.length 1) then
error (Full Stack) else
t t + 1S[t] o
Stacks 7
Example: What does this code slice do?
int main( ) {int n;double item;double numbers[n]; printf( " Type in an integer n followed by n decimal numbers.\n");
printf(" The numbers will be printed in reverse order.\n”);scanf(“%d”, &n);for (int i = 0; i < n; i++) {
scanf(“%d, &item);push(item);
}printf( “\n\n”);while (!empty( )) {
printf( “%d ”, getTop( ));item = pop( );
}return 0;}
Stacks 8
Stack: Exampleconst int MaxStack = 10; const char EmptyFlag = '\0';
int top; int items[MaxStack];
enum { FullStack = MaxStack, EmptyStack = -1 }; // better enum Err_code {FullStack ...}
top = EmtyStack;
bool push(int); int pop(); int getTop()
bool empty(); bool full();
bool push(int x){
if (full()) return false;
items[++top] = x;
return true;
}
int pop(){
if (empty()) return EmptyFlag;
return items[top--];
}
int getTop(){
if (empty()) return EmptyStack;
return items[top];
}
Stacks 9
Stack: Examplebool full() {
if (top + 1 == FullStack) {
printf( "Stack Full at %d \n“, MaxStack);
return true;
}
return false;
}
bool empty(){
if (top == EmptyStack) {
printf("Stack empty \n“);
return true;
}
return false;
}
int main(void){
/* Define stack */
int s1 [ MaxStack ];
/* fill in here the necessary statements that use stack functions */
}
Stacks 10
Exp: Prime Divisors of a Number
Read an integer and print all its prime divisors in descending order. Note that the smallest divisor greater than 1
of any integer is guaranteed to be a prime 2100/2 = 1050 + 02100/2 = 1050 + 0 1050/2 = 525 + 01050/2 = 525 + 0 525/3 = 175 + 0525/3 = 175 + 0 175/5 = 35 + 0175/5 = 35 + 0 35/5 = 7 + 035/5 = 7 + 0 7/7= 1 + 07/7= 1 + 0 7*5*5*3*2*2 = 21007*5*5*3*2*2 = 2100
Stacks 11
Reverse Polish Calculator
? Read an operand push it onto the stack+,-,*,/ Arithmetic operations= Print the top of the stackExamples:
?a?b+= Read and store a and b, calculate and store their sum, and then print the sum (a+b)=
?a?b +?c?d+*= do (a+b)*(c+d) and print ?a?b?c - = * ?d + = do (a*(b-c))+d and print:
1. Push a, b, c onto the stacks,2. Replace the pair b,c by b-c and print its value,3. Calculate a*(b-c),4. Push d onto the stack.5. Finally, calculate and print (a*(b - z)) + d.
Stacks 12
Get command of calculator
char get command( ){
char command;bool waiting = true;printf( "Select command and press < Enter > :“);while (waiting) {
scanf(“%c”, &command);command = tolower(command);if (command == ‘?’ || command == ‘=’ || command == ‘+’ || command == ‘−’|| command == ‘*’ || command == ‘/’
||command == ‘q’) waiting = false;
else {printf( "Please enter a valid command: \n" );printf(“[?]push to stack [=]print top \n");printf(“[+] [−] [*] [/] are arithmetic operations \n");printf(“[Q]uit. \n");
}}return command;}
Stacks 13
Adding and printing ?p?q+=bool do_command(char command) { double p, q;switch (command) {
case ‘?’:printf(“Enter a number: "); flush(); scanf(“%d, &p);if (push(p) == false)
printf(“Warning: Stack full, lost number \n"); break;case ‘=’: if ( (p = getTop()) == EmptyFlag) printf(“Stack empty \n”); else printf(“%d \n”, p); break;case ‘+’: if ((p = getTop()) == EmptyFlag) printf(“Stack empty \n”); else { p = pop( ); if ((q = getTop()) == EmptyFlag {
printf(“Stack has just one entry\n”);push(p);
} else { q = pop( ); if (push(q + p) == false) printf(“Warning: Stack full, lost result\n”);
} } break;/* Add options for further user commands. */case ‘q’: printf(“Calculation Finished.\n"; return false;} return true; }
Stacks 14
Exp: Bracket checkingint main( )/* Post: Notice the use of any bracket mismatch in the standard input */char symbol, match;bool is_matched = true;while (is_matched && (symbol = getchar( )) != “\n”) {
if (symbol == ‘{‘ || symbol == ‘(‘ || symbol == ‘[‘)push(symbol);
if (symbol == ‘}’ || symbol == ‘)’ || symbol == ‘]’) { if (empty( )) { printf("Unmatched closing bracket %c detected \n“); is_matched = false; }else { match = getTop(); match = pop( ); is_matched = (symbol == ‘}’ && match == ‘{‘) || (symbol == ‘)’ && match == ‘(‘) || (symbol == ‘]’ && match == ‘[‘); if (!is_matched) printf("Bad match %c %c \n“, match, symbol”);}
}}if (! empty( ))
printf("Unmatched opening bracket(s) detected.\n“);}
Stacks 15
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
Stacks 16
Computing Spans
Given an an array X, the span S[i] of X[i] is the maximum number of consecutive elements X[j] immediately preceding X[i] such that X[j] X[i] Spans have applications to financial analysis E.g., stock at 52-week
high6 3 4 5 2
1 1 2 3 1
X
S
01234567
0 1 2 3 4
Stacks 17
Quadratic AlgorithmAlgorithm spans1(X, n)
Input array X of n integersOutput array S of spans of X #S new array of n integers nfor i 0 to n 1 do n
s 1 nwhile s i X[i s] X[i] 1 2 … (n 1)
s s 1 1 2 … (n 1)S[i] s n
return S 1
Algorithm spans1 runs in O(n2) time
Stacks 18
Computing Spans with a Stack
Keep in a stack the indices of the elements visible when “looking back”Scan the array from left to right
Let i be the current index
Pop indices from the stack until finding index j such that X[i] X[j]
Set S[i] i j Push x onto the stack
01234567
0 1 2 3 4 5 6 7
Stacks 19
Linear AlgorithmAlgorithm spans2(X, n) #
S new array of n integers nA new empty stack 1
for i 0 to n 1 do nwhile (A.isEmpty()
X[top()] X[i] ) do nj A.pop() n
if A.isEmpty() then nS[i] i 1 n
else S[i] i j n
A.push(i) nreturn S 1
Each index of the array
Is pushed into the stack exactly once
Is popped from the stack at most once
The statements in the while-loop are executed at most n times Algorithm spans2 runs in O(n) time
Stacks 20
Growable Array-based Stack
In a push operation, when the array is full, instead of throwing an exception, we can replace the array with a larger oneHow large should the new array be? incremental strategy:
increase the size by a constant c
doubling strategy: double the size
Algorithm push(o)if t = S.length 1 then
A new array ofsize …
for i 0 to t do A[i] S[i] S A
t t + 1S[t] o
Stacks 21
Comparison of the Strategies
We compare the incremental strategy and the doubling strategy by analyzing the total time T(n) needed to perform a series of n push operationsWe assume that we start with an empty stack represented by an array of size 1We call amortized time of a push operation the average time taken by a push over the series of operations, i.e., T(n)/n
Stacks 22
Incremental Strategy Analysis
We replace the array k = n/c timesThe total time T(n) of a series of n push operations is proportional to
n + c + 2c + 3c + 4c + … + kc =n + c(1 + 2 + 3 + … + k) =
n + ck(k + 1)/2Since c is a constant, T(n) is O(n + k2), i.e., O(n2)The amortized time of a push operation is O(n)
Stacks 23
Doubling Strategy AnalysisWe replace the array k = log2 n timesThe total time T(n) of a series of n push operations is proportional to
n + 1 + 2 + 4 + 8 + …+ 2k =n 2k + 1 1 = 2n 1
T(n) is O(n)The amortized time of a push operation is O(1)
geometric series
1
2
14
8