The presentation given at PCCOE, Nigdi, Pune by Prof. Tushar B Kute in workshop on "See through C". http://tusharkute.com

1. See through C
Module 1
Stack and Recursion
Tushar B Kute
http://tusharkute.com

2. Overview
Subjects:
• Stacks
– Structure
– Methods
– Stacks and Method – Calls
• Recursion
– Principle
– Recursion and Stacks
– Examples

3. Stack: Properties
Answer:
They both provide LIFO (last in first out)
Structures
1
2
3
4
5
6
1
2
3
4
5
6

4. Stacks: Properties
Possible actions:
• PUSH an object (e.g. a plate) onto dispenser
• POP object out of dispenser

5. Stacks: Definition
Stacks are LIFO structures, providing
• Add Item (=PUSH) Methods
• Remove Item (=POP) Methods
They are a simple way to build a collection
• No indexing necessary
• Size of collection must not be predefined
• But: extremely reduced accessibility

6. A look into the JVM
1 int main( ) {
2 int a = 3;
3 int b = times(a);
4 printf(“%d“, b);
5 }
6 int times(int a) {
7 int b = 5;
8 int c = a * b;
9 return (c);
10 }
a = 3
a = 3
b
Return to LINE 3
b = 5
c = 15

7. A look into the compiler
...
9 return (c);
10 ...
a = 3
a = 3
b
Return to LINE 3
b = 5
c = 15
15
a = 3
b
Return to LINE 3
a = 3
b
c = 15
Return to LINE 3
Temporary storage
Clear Stack

8. A look into the CompilerA look into the
1 int main() {
2 int a = 3;
3 int b = times(a);
4 printf(“%d“, b);
5 }
a = 3
b
c = 15
Temporary storage
a = 3
b = 15

9. A look into the CompilerA look into the
1 int main() {
2 int a = 3;
3 int b = times(a);
4 printf(“%d“, b);
5 }
clear stack from local variables

10. A look into the CompilerA look into the
Important:
Every call to a function creates a
new set of local variables !
These Variables are created on the stack and
deleted when the function returns

11. Applications using a Stack
Examples:
• Finding Palindromes
• Bracket Parsing
• RPN
• RECURSION !

12. RecursionRecursion

13. RecursionRecursion
• Sometimes, the best way to solve a problem is
by solving a smaller version of the exact same
problem first
• Recursion is a technique that solves a
problem by solving a smaller problem of the
same type
• A function that is defined in terms of itself

14. RecursionRecursion
When you turn that into a program, you end
up with functions that call themselves:
Recursive Functions

15. RecursionRecursion
int fact (int a)
{
if (a==1)
return(1);
else
return (a * fact( a-1));
}
It computes f! (factorial)
What’s behind this function ?

16. Factorial:
a! = 1 * 2 * 3 * ... * (a-1) * a
Note:
a! = a * (a-1)!
remember:
...splitting up the problem into a smaller problem of the same type...
a!
a * (a-1)!
Factorial

17. int factorial(int a){
if (a==0)
return(1);
else
return(a * factorial( a-1));
}
Tracing the example

18. int factorial (int a){
if (a==1)
return(1);
else
return(a * factorial( a-1));
}
Watching the Stack
a = 5 a = 5 a = 5
Return to L4
a = 4
Return to L4
a = 4
Return to L4
a = 3
Return to L4
a = 2
Return to L4
a = 1
Initial After 1 recursion After 4th
recursion
…
Every call to the method creates a new set of local
variables !

19. int factorial(int a){
if (a==1)
return(1);
else
return(a * factorial( a-1));
}
Watching the Stack
a = 5
Return to L4
a = 4
Return to L4
a = 3
Return to L4
a = 2
Return to L4
a = 1
After 4th
recursion
a = 5
Return to L4
a = 4
Return to L4
a = 3
Return to L4
a = 2*1 = 2
a = 5
Return to L4
a = 4
Return to L4
a = 3*2 = 6
a = 5
Return to L4
a = 4*6 = 24
a = 5*24 = 120
Result

20. Problems that can be solved by recursion have these characteristics:
• One or more stopping cases have a simple, nonrecursive solution
• The other cases of the problem can be reduced (using recursion)
to problems that are closer to stopping cases
• Eventually the problem can be reduced to only stopping cases,
which are relatively easy to solve
Follow these steps to solve a recursive problem:
• Try to express the problem as a simpler version of itself
• Determine the stopping cases
• Determine the recursive steps
Properties of Recursive Functions

21. The recursive algorithms we write generally consist of an if statement:
IF
the stopping case is reached solve it
ELSE
split the problem into simpler cases using recursion
Solution
Solution on stack
Solution on stack
Solution on stack

22. Recursion does not terminate properly:
Stack Overflow !
Common Programming Error

23. Examples: Fractal Tree
http://id.mind.net/~zona/mmts/geometrySection/fractals/tree/treeFractal.html

24. Examples: The 8 Queens Problem
http://mossie.cs.und.ac.za/~murrellh/javademos/queens/queens.html
Eight queens are to be placed on a chess board
in such a way that no queen checks against
any other queen

25. Thank you
This presentation is created using LibreOffice Impress 3.6.2.2