recursion english –return (oxford/webster) –procedure repeating itself indefinitely or until...
Post on 19-Dec-2015
217 views
TRANSCRIPT
![Page 1: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/1.jpg)
Recursion• English
– Return (Oxford/Webster)
– procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster)
• adequate: satisfactory
• satisfactory: adequate
– recursion: recursion
• Mathematics
– expression giving successive terms of a series (Oxford)
• Programming– Method calling itself.
– On a smaller problem.
– Alternative to loops.
![Page 2: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/2.jpg)
Recursion
• Recursive Functions
• Recursive Procedures
• Number-based Recursion
• List-based Recursion
![Page 3: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/3.jpg)
factoroial (n)public static int factorial (int n) { int product = 1; while (n > 0) { product *= n; n -= 1; } return product; }
public static void main (String[] args) {while (true) {// loop condition never false
int n = Keyboard.readInt();if (n < 0)
break;System.out.println(“factorial =“ + factorial(n);
} }
1*2*3*4 … n
![Page 4: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/4.jpg)
Defining factorial(n)
Product of the first n numbers.
1*2*3*4 … n
factorial (0) = 1
factorial (1) = 1 = 1* factorial(0)
factorial (2) = 2*1 = 2* factorial(1)
factorial (3) = 3*2*1 = 3* factorial(2)
factorial (4) = 4*3*2*1 = 4* factorial(3)
factorial (n) = n*n-1*..*1 = n* factorial(n-1)
![Page 5: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/5.jpg)
Defining factorial(n)
factorial (n) = 1
factorial (n) = n* factorial(n-1)
if n == 0
if n > 0
![Page 6: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/6.jpg)
Implementing factorial(n) (edit)
factorial (n) = 1
factorial (n) = n* factorial(n-1)
if n == 0
if n > 0
public static int factorial (int n) { ??? }
![Page 7: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/7.jpg)
Implementing factorial(n) (edited)
factorial (n) = 1
factorial (n) = n* factorial(n-1)
if n == 0
if n > 0
public static int factorial (int n) { if (n == 0) return 1; if (n > 0) return n*factorial(n-1); }
![Page 8: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/8.jpg)
Implementing factorial(n)
factorial (n) = 1
factorial (n) = n* factorial(n-1)
if n == 0
if n > 0
public static int factorial (int n) { if (n == 0)
return 1; if (n > 0)
return n*factorial(n-1); }
Function must return something for all cases
n < 0 ?
![Page 9: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/9.jpg)
Implementing factorial(n)
factorial (n) = 1
factorial (n) = n* factorial(n-1)
if n == 0
if n > 0
public static int factorial (int n) { if (n == 0)
return 1; else if (n < 0)
return factorial(-n); else
return n*factorial(n-1); }
Recursive reduction steps
Base case
factorial (n) = - factorial(n) if n < 0
![Page 10: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/10.jpg)
General form of Recursive Methodif (base case 1 ) return solution for base case 1else if (base case 2) return solution for base case 2….else if (base case n) return solution for base case nelse if (recursive case 1) do some preprocessing recurse on reduced problem do some postprocessing…else if (recursive case m) do some preprocessing recurse on reduced problem do some postprocessing
![Page 11: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/11.jpg)
Recursion Vs Loops (Iteration)
public static int factorial (int n) { if (n == 0)
return 1; else if (n < 0)
return factorial(-n); else
return n*factorial(n-1); }
public static int factorial (int n) { int product = 1; while (n > 0) { product *= n; n -= 1; } return product; }
Implementation follows from definition.
![Page 12: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/12.jpg)
Tracing Recursive Calls
Stack
![Page 13: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/13.jpg)
Tracing Recursive Calls
Invocation n return valuefactorial(1) 1 ?factorial(2) 2 ?
Invocation n return valuefactorial(0) 0 ?factorial(1) 1 ?factorial(2) 2 ?
Invocation n return valuefactorial(0) 0 1factorial(1) 1 ?factorial(2) 2 ?
Invocation n return valuefactorial(0) 0 1factorial(1) 1 1factorial(2) 2 ?
Invocation n return valuefactorial(0) 0 1factorial(1) 1 1factorial(2) 2 2
![Page 14: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/14.jpg)
Recursion Pitfalls
public static int factorial (int n) {
return n*factorial(n-1); }
factorial (2)
2* factorial (1)
1* factorial (0)
0* factorial (-1)
-1 * factorial(-2)Infinite recursion! (Stack overflow)
No base case....
![Page 15: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/15.jpg)
Recursion Pitfalls
factorial (2)
factorial (3) / 3
factorial (4) / 4
factorial (5) / 5
factorial(6) / 6Infinite recursion!
Recurses on bigger problem....
public static int factorial (int n) { if (n == 0)
return 1; else if (n < 0)
return factorial(-n); else
return factorial(n+1)/n+1; }
![Page 16: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/16.jpg)
Recursive Methods
• Should have base case(s)
• Recurse on smaller problem(s) - recursive calls should converge to base case(s)
![Page 17: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/17.jpg)
Recursive Functions with Multiple Parameters
power (base, exponent)
base*base*base*…*base
power (0, exponent) = 0
exponent # of times
baseexponent
power (1, exponent) = 1power (2, exponent) = 2*2*2…*2 (exponent times)power (3, exponent) = 3*3*3…*3 (exponent times)
No pattern!
![Page 18: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/18.jpg)
Recursive Functions with Multiple Parameters (edit)
power (base, exponent)
base*base*base*…*base
exponent # of times
baseexponent
?????
![Page 19: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/19.jpg)
Recursive Functions with Multiple Parameters (edited)
power (base, exponent)
base*base*base*…*base
exponent # of times
baseexponent
power(base, 0) = 1
power(base, 1) = base * 1 = base*power(base, 0)
power(base, 2) = base*base*1 = base* power(base, 1)
power(base,exponent) = base*power(base, exponent-1)
![Page 20: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/20.jpg)
Recursive Functions with Multiple Parameters
power (base, exponent)
base*base*base*…*base
exponent # of times
baseexponent
power (base, 0) = 1
power (base, 1) = base*1 = base* power(base, 0)
power (base, 2) = base*base*1 = base* power(base, 1)
power (base, exponent) = base*power(base, exponent-1)
![Page 21: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/21.jpg)
Defining power(base, exponent)
power (base, exponent) = 1 if exponent <= 0
power (base, exponent) = base*power(base, exponent-1) if exponent <= 0
public static int power (int base, exponent) { if (n <= 0)
return base; else
return base*power(base, exponent-1); }
![Page 22: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/22.jpg)
Recursive Procedures: greet(n)
greet (1)
print “hello”
greet (0) greet (2) greet(n)
n times
print “hello”
print “hello”
print “hello”
print “hello”
print “hello”
print “hello”
![Page 23: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/23.jpg)
Defining greet(n) (edit)
greet (1)
print “hello”
greet (0) greet (2) greet(n)
n times
print “hello”
print “hello”
print “hello”
print “hello”
print “hello”
print “hello”
![Page 24: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/24.jpg)
Defining greet(n) (edited)
greet (1)
print “hello”
greet (0) greet (2) greet(n)
n times
print “hello”
print “hello”
print “hello”
print “hello”
print “hello”
print “hello”
Do nothing;
Print “hello”;
greet(0);Print “hello”;
greet(1);
Print “hello”;
greet(n-1);
greet(n-1);
Print “hello”;
![Page 25: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/25.jpg)
Defining greet(n)
greet (1)
print “hello”
greet (0) greet (2) greet(n)
n times
print “hello”
print “hello”
print “hello”
print “hello”
print “hello”
print “hello”greet(0);
print “hello”; greet(1);
print “hello”;
do nothing;
greet(n-1);
print “hello”;
![Page 26: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/26.jpg)
Defining greet(n)
greet(n) if n <= 0
greet(n) if n > 0
do nothing;
greet(n-1); print “hello”
![Page 27: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/27.jpg)
Implementing greet(n) (edit)
greet(n) if n <= 0
greet(n) if n > 0
???
do nothing;
greet(n-1); print “hello”
![Page 28: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/28.jpg)
Implementing greet(n) (edited)
greet(n) if n <= 0
greet(n) if n > 0
Public static void greet(int n) {if (n>0) {
System.out.println(“hello”);greet(n-1);
}}
do nothing;
greet(n-1); print “hello”
![Page 29: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/29.jpg)
Implementing greet(n)
greet(n) if n <= 0
greet(n) if exponent <= 0
public static void greet (int n) { if (n > 0) {
greet(n-1);System.out.println(“hello”);
}
do nothing;
greet(n-1); print “hello”
![Page 30: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/30.jpg)
List-based recursion: multiplyList()
multiplyList () = 1 if remaining input is: -1
multiplyList () = 2 if remaining input is: 2 -1
multiplyList () = 2*6 if remaining input is: 2 6 -1
![Page 31: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/31.jpg)
List-based recursion: multiplyList() (edited)
multiplyList () = 1 if nextVal <= 0
multiplyList () = 2 if input is: 2 -1
multiplyList () = 2*6 if input is: 2 6 -1
multiplylist() = readNextVal() * multiplylist() if nextVal > 0
![Page 32: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/32.jpg)
List-based recursion: multiplyList()
multiplyList () = 1 if nextVal < 0
multiplyList () = readNextVal()*multiplyList() if nextVal > 0
public static int multiplyList () { int nextVal = Keyboard.readInt(); if (nextVal < 0) return 1; else return nextVal*multiplyList() }
![Page 33: Recursion English –Return (Oxford/Webster) –procedure repeating itself indefinitely or until condition met, such as grammar rule (Webster) adequate: satisfactory](https://reader035.vdocument.in/reader035/viewer/2022062515/56649d2b5503460f94a00414/html5/thumbnails/33.jpg)
Tracing multiplyList()
public static int multiplyList () { int nextVal = Keyboard.readInt(); if (nextVal < 0) return 1; else return nextVal*multiplyList() }
Invocation Remaininginput
return value
multiplyList() 2 30 -1 ???
Invocation Remaininginput
return value
multiplyList() 30 -1 ???multiplyList() 2 30 -1 ???
Invocation Remaininginput
return value
multiplyList() -1 ???multiplyList() 30 -1 ???multiplyList() 2 30 -1 ???
Invocation Remaininginput
return value
multiplyList() -1 1multiplyList() 30 -1 ???multiplyList() 2 30 -1 ???
Invocation Remaininginput
return value
multiplyList() -1 1multiplyList() 30 -1 30multiplyList() 2 30 -1 ???
Invocation Remaininginput
return value
multiplyList() -1 1multiplyList() 30 -1 30multiplyList() 2 30 -1 60