Title: Class Prep
1Class Prep
- Bring to Class
- In-Class Exercises
- Paper for Classroom Printer
- Copy programs to MATLAB folder
- Run MATLAB
2Grab Files
- While we are waiting for class to start, copy
push.m, pop.m, top.m, numberOfDigits.m,
cs70ex7a.m from the course folder - Set MATLAB Current Directory
3Week 07-a(91.-9.5)
4Reminder Test Coming Up Next Class
- Test 2 will not cover the new material from
today to make sure that you have had enough time
between presentation and testing. - Sample Test is accessible via a link on course
schedule on course web page - cs.union.edu/csc070/tests
- Once you have had a chance to work on the
questions, feel free to send me an email message
requesting the answers
5Algorithm Study for CSc-70 Test
- Take Practice Test, then Request Answers
- Don't understand something? Email or see HannayD
- Redo In-Class Exercises
- Don't understand something? Email or see HannayD
- Redo HW on Without Help from Others
- Don't understand something? Email or see HannayD
- Go Over Lecture Notes
- Don't understand something? Email or see HannayD
- Study Textbook, add Notes to Text
- Don't understand something? Email or see HannayD
6Concept Basic Stack Operations
The Activation Stack is a stack used by the
operating system to manage the execution of
function calls
7A "stack"
- Dishes and trays
- Last one in is first one out
- (don't know how deep it is, and don't care)
- Can get the "top" value
- A stack is used for functions to get space for
it's arguments, internal data, and it's return
location - Each call to a function gets the room it needs on
the stack ("pushed" onto the stack). - Allows calling function over and over
8Hands-On DEMO Pushdown Stack
- Make sure that push.m, pop.m, and top.m are in
your current directory (format compact) - gtgt push(25)
- gtgt push(34)
- gtgt pop
- gtgt top
- gtgt pop
- gtgt pop
- gtgt top
9Pushdown Stack for Function Calls
- Stack is a data structure
- First In, Last Out (like cafeteria trays)
- Stack used to automatically track info for
function calls - return addresses
- call-by-value parameters
- local variables
- Every time a function is called, a set of data
goes on the stack, it disappears when the
function returns - Recursion the stack grows
10Function Specification vs Function Instances
- The file defining the function merely specifies
how it would behave if you ever called it. This
is the function specification. - When you call the function, a stack frame is
created, parameter values are supplied and you
have a fully defined instance of that function. - There is no reason in principle why a function
cannot call itself, because each call is a
different instance of the function.
11Recursion
- Recursion is a basic problem solving technique
that divides a problem into smaller subproblems - These subproblems may also be divided into
smaller subproblems - When the subproblems are small enough to solve
directly the process stops - A recursive algorithm is a problem solution that
has been expressed in terms of two or more easier
to solve subproblems
12Illegal Recursion
- Recursive Directions--Infinite Recursion
- "Back to the Future"--Infinite Recursion
13Recursion is Mysterious
- You must ass u me that a function already exists
as you are defining it. - "Leap of Faith"
14The Two Requirements
- 1) Base (Stopping) Case
- Recursion stops here
- Missing with Ziggy and Michael J. Fox
- 2) Inductive (Recursive) Case
- Convert to simpler problem
- Also missing with Ziggy and Michael J. Fox
- They call for the same problem again
- Basic structure of a recursive function
- if (base case is reached)
- give solution
- else
- reduce problem to simpler version using recursion
15Counting Digits in n
- Recursive definition
- if n is between and not equal to 10 and 10
- the number of digits is 1
- else
- the number of digits is 1 more than the number
of digits in n/10 - Example
- digits(321) 1 digits(321/10) 1
digits(32) - 1 1 digits(32/10) 1
1 digits(3) - 1 1 (1)
- 3
16Hands-On DEMO Counting Digits Function
- function digits numberOfDigits(n)
- if (abs(n) lt 10)
- digits 1
- else
- digits 1 numberOfDigits(n/10)
- end
- NOTE No Loop, but we still are "repeating"
something...
17Factorial
- Write a function that, given n, computes n!
- n! 1 2 ... (n-1) n
- Example
- 5! 1 2 3 4 5 120
- Specification
- Receive n, an integer.
- Precondition n gt 0
- Return n!.
18Analysis
- Consider n! 1 2 ... (n-1) n
- but (n-1)! 1 2 ... (n-1)
- substituting n! (n-1)! n
- We have defined the ! function in terms of
itself. - Historically, this is how the function was
defined before computers (and for-loops) existed.
19Base Case
- Recursive functions are designed in a 3-step
process - 1. Identify a base case -- an instance of the
problem whose solution is trivial. - Example The factorial function has two base
cases - if n 0 n! 1
- if n 1 n! 1
20Induction Step
- 2. Identify an induction step -- a means of
solving the non-trivial (or big) instances of
the problem using one or more smaller instances
of the problem. - Example In the factorial problem, we solve the
big problem using a smaller version of the
problem - n! (n-1)! n
- 3. Form an algorithm from the base case and
induction step.
21Algorithm
- // factorial(n)
- Receive n.
- if n lt 1
- return 1.
- else
- return factorial(n-1) n.
- Factorial Exercise
- Each become an "instance" of the function
22Hands-On DEMO Factorial Example
- function result fact(n)
- if (n lt 1)
- result 1
- else
- result n fact(n-1)
- end
- Obviously, we could have said result prod(1n),
but that wouldn't give us such a nice example of
recursion!
23Activation Stack for Factorial
- Call the function answer fact(5)
main program Unfinished answer
fact (5)
24Activation Stack for Factorial
fact. 1st N5, Unfinished
5fact(4)
main program Unfinished answer
fact (5)
25Activation Stack for Factorial
fact. 2nd N4, Unfinished
4fact(3)
fact. 1st N5, Unfinished
5fact(4)
main program Unfinished answer
fact (5)
26Activation Stack for Factorial
fact. 3rd N3, Unfinished
3fact(2)
fact. 2nd N4, Unfinished
4fact(3)
fact. 1st N5, Unfinished
5fact(4)
main program Unfinished answer
fact (5)
27Activation Stack for Factorial
fact. 4th N2, Unfinished
2fact(1)
fact. 3rd N3, Unfinished
3fact(2)
fact. 2nd N4, Unfinished
4fact(3)
fact. 1st N5, Unfinished
5fact(4)
main program Unfinished answer
fact (5)
28Activation Stack for Factorial
fact. 5th N1, Finished
return 1
fact. 4th N2, Unfinished
2fact(1)
fact. 3rd N3, Unfinished
3fact(2)
fact. 2nd N4, Unfinished
4fact(3)
fact. 1st N5, Unfinished
5fact(4)
main program Unfinished answer
fact (5)
29Activation Stack for Factorial
fact. 4th N2, Finished returns 21
fact. 3rd N3, Unfinished
3fact(2)
fact. 2nd N4, Unfinished
4fact(3)
fact. 1st N5, Unfinished
5fact(4)
main program Unfinished answer
fact (5)
30Activation Stack for Factorial
fact. 3rd N3, Finished
returns 32
fact. 2nd N4, Unfinished
4fact(3)
fact. 1st N5, Unfinished
5fact(4)
main program Unfinished answer
fact (5)
31Activation Stack for Factorial
fact. 2nd N4, Finished
returns 46
fact. 1st N5, Unfinished
5fact(4)
main program Unfinished answer
fact (5)
32Activation Stack for Factorial
Fact. 1st N5, Finished
returns 524
main program Unfinished answer
fact (5)
33Activation Stack for Factorial
main program Finished answer
120
34Summary Characteristics of Recursion
- Answer requires calling same function again
- Think of it as a clone and I never run out of
clones - each with their own copies of data on
the stack. "Instance" - Stopping condition
- Call with different parameters moving closer to
the stopping condition - Each call to the next clone has different
parameters than the previous call "closer" to
the stopping condition
35Recursive Binary Search (c.f.Guess the Number)
- Basic algorithm
- If target is middle value, we are done
- Else if target is less than middle value, search
in lower half - Else target is greater than middle value search
in upper half - What about case where target is not in array?
What will happen? - Base case(s)
- Inductive step(s)
36Recursive Binary Search
- function where binSearch(List, lookingFor,
first, last) - if (first gt last)
- where -1
- else
- next fix((firstlast)/2)
- if lookingFor List(next)
- where next
- elseif lookingFor gt List(next)
- where binSearch(List, lookingFor, next1,
last) - else
- where binSearch(List, lookingFor, first,
next-1) - end
- end
37Hands-On DEMO Recursive "power" Function
- Write a recursive algorithm to calculate the nth
power of x - x x x x x (n times)
- Base case?
- what condition?
- return what?
- Inductive step?
- what simpler call to the same function?
- (see next slide for answer)
38Evaluating Exponents Recursively
- function pow power(x, n)
- raise x to the power n
- precondition n gt 0
- if (n 0)
- pow 1
- else
- pow x power(x, n 1)
- end
39Divide and Conquer
- Using this method, each recursive subproblem is
about one-half the size of the original problem - If we could define power so that each subproblem
was based on computing kn/2 instead of kn 1 we
could use the divide and conquer principle - Efficiency of Binary Search vs. Linear Search
- Recursive divide and conquer algorithms are often
more efficient than iterative algorithms
40Evaluating Exponents Using Divide and Conquer
- function pow myPower(x, n)
- if (n 0)
- pow 1
- else
- tmp myPower(x, fix(n/2))
- if (rem(n, 2) 0)
- pow tmp tmp
- else
- pow x tmp tmp
- end
- end
41Review the 2 Requirements
- 1) Base (Stopping) Case
- Recursion stops here
- 2) Inductive (Recursive) Case
- Convert to simpler problem
- Basic structure of a recursive function
- if (base case is reached)
- give solution
- else
- reduce problem to simpler version using recursion
What happens if we forget to include the base
case?
42In-Class Exercise 7a Compound Interest(given
cs70ex7a.m)
- Non-Recursive Formula
- Value StartingValue(1interest)n
- Recursively,
- Value(0) StartingValue
- Value(period) Value(period-1)(1interest)
- Write a function, rCompound using recursion to
compute the amount of money in your account at
the end of "n" periods. Your function will be
sent - Starting Value, Interest Rate, Number of Periods
- Test with 1000, 0.05, 20 and 10000, 0.07, 25
- Both calls in same main program cs70ex7a.m
43END