Scribd
Upload
23 views34 pages

Welcome To CIS 068 !: Stacks and Recursion

cis

Uploaded by

Rohit Tiwari
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
23 views34 pages

Welcome To CIS 068 !: Stacks and Recursion

cis

Uploaded by

Rohit Tiwari
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 34

Welcome to CIS 068 !

Stacks and Recursion

CIS 068

Overview
Subjects:
Stacks
Structure
Methods

Stacks and Method Calls

Recursion
Principle
Recursion and Stacks
Recursion vs. Iteration
Examples
CIS 068

Stacks: Introduction
What do these tools have in common ?

Plate Dispenser

PEZ Dispenser
CIS 068

Stack: Properties
Answer:
They both provide LIFO (last in first out)
Structures
6

5
4
3
2
1

6
5
4
3
2
1
CIS 068

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

CIS 068

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
CIS 068

Stacks
Application Areas
LIFO order is desired
See JVM-example on next slides

...or simply no order is necessary


Lab-assignment 5: reading a collection of
coordinates to draw

CIS 068

Stacks
Q:
How would you implement a Stack ?

CIS 068

A look into the JVM


Sample Code:
1 public static void main(String args[ ]){

int a = 3;

int b = timesFive(a);

System.out.println(b+);

5 }

6 Public int timesFive(int a){


7

int b = 5;

int c = a * b;

return (c);

10 }
CIS 068

A look into the JVM


Inside the JVM a stack is used to

create the local variables

to store the return address from a


call

to pass the method-parameters

CIS 068

A look into the JVM


1 public static void main(String args[ ]){
2

int a = 3;

int b = timesFive(a);

System.out.println(b+);

Public int timesFive(int a){


c = 15

int b = 5;

int c = a * b;

return (c);

10

b=5
a=3
Return to LINE 3
b
a=3

CIS 068

A look into the JVM


...

Temporary storage

15

return (c);

10

...

Return to LINE 3

Return to LINE 3

c = 15
b=5
a=3
Return to LINE 3

c = 15

Clear Stack

a=3

a=3

a=3
CIS 068

A look into the JVM


1 public static void main(String args[ ]){
2

int a = 3;

int b = timesFive(a);

System.out.println(b+);

c = 15
b

b = 15

a=3

a=3

Temporary storage
CIS 068

A look into the JVM


1 public static void main(String args[ ]){
2

int a = 3;

int b = timesFive(a);

System.out.println(b+);

clear stack from local variables

CIS 068

A look into the JVM


Important:

Every call to a method creates a


new set of local variables !
These Variables are created on the stack and
deleted when the method returns

CIS 068

Applications using a Stack


Examples:

Finding Palindromes

Bracket Parsing

RPN

RECURSION !

CIS 068

Recursion

CIS 068

Recursion

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 procedure that is defined in terms of itself

CIS 068

Recursion
When you turn that into a program, you end
up with functions that call themselves:

Recursive Functions

CIS 068

Recursion
Whats behind this function ?
public int f(int a){
if (a==1)
return(1);
else
return(a * f( a-1));
}

It computes f! (factorial)
CIS 068

Factorial
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-1)!

CIS 068

Tracing the example


public int factorial(int a){
if (a==0)
return(1); RECURSION
else
return(a * factorial( a-1));
}

CIS 068

Watching the Stack


public int factorial(int a){
if (a==1)
return(1);
else
return(a * factorial( a-1));
}

a=5
Initial

a=4
Return to L4
a=5
After 1 recursion

a=1
Return to L4
a=2
Return to L4
a=3
Return to L4
a=4
Return to L4
a=5
After 4th recursion

Every call to the method creates a new set of local


variables !
CIS 068

Watching the Stack


public int factorial(int a){
if (a==1)
return(1);
else
return(a * factorial( a-1));
}
a=1
Return to L4
a=2
Return to L4
a=3
Return to L4
a=4
Return to L4
a=5
After 4th recursion

a = 2*1 = 2
Return to L4
a=3
Return to L4
a=4
Return to L4
a=5

a = 3*2 = 6
Return to L4
a=4
Return to L4
a=5

a = 4*6 = 24
Return to L4
a=5

a = 5*24 = 120
Result

CIS 068

Properties of Recursive Functions


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

CIS 068

Solution
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 on stack
Solution on stack
Solution on stack
CIS 068

Common Programming Error

Recursion does not terminate properly:


Stack Overflow !

CIS 068

Exercise
Define a recursive solution for the following function:

f(x) = x

CIS 068

Recursion vs. Iteration


You could have written the power-function
iteratively, i.e. using a loop construction

Wheres the difference ?

CIS 068

Recursion vs. Iteration

Iteration can be used in place of recursion


An iterative algorithm uses a looping
construct
A recursive algorithm uses a branching
structure
Recursive solutions are often less efficient, in
terms of both time and space, than iterative
solutions
Recursion can simplify the solution of a
problem, often resulting in shorter, more easily
understood source code
(Nearly) every recursively defined problem can
be solved iteratively iterative optimization
can be implemented after recursive design CIS 068

Deciding whether to use a Recursive Function

When the depth of recursive calls is relatively


shallow
The recursive version does about the same
amount of work as the nonrecursive version
The recursive version is shorter and simpler
than the nonrecursive solution

CIS 068

Examples: Fractal Tree


http://id.mind.net/~zona/mmts/geometrySection/fractals/tree/treeFractal.html

CIS 068

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
CIS 068

Review
A stack is a simple LIFO datastructure used e.g.
by the JVM to create local variable spaces
Recursion is a divide and conquer designing
technique that often provides a simple algorithmic
structure
Recursion can be replaced by iteration for reasons
of efficiency
There is a connection between recursion and the
use of stacks
There are interesting problems out there that can
be solved by recursion
CIS 068

You might also like