2.3 Recursion 7/21/2014 5:12:34 PM

Transcription

1 3 Recursion Introduction to Programming in Java: An Interdisciplinary Approach Robert Sedgewick and Kevin Wayne Copyright /21/2014 5:12:34 PM

2 Factorial The factorial of a positive integer N is computed as the product of N with all positive integers less than or equal to N. 4! = = 24 30! = =

3 Factorial - Iterative Implementation int b = factorial(5); static int factorial(int n) { int f = 1; for (int i=n; i>=1; i--) { f = f * i; Trace it.

4 5! = ! = ! = 5 4! N! = N (N-1)! Factorial can be defined in terms of itself

5 Recursion

6 Recursion

7 Overview What is recursion? When one function calls itself directly or indirectly. Why learn recursion? New mode of thinking Powerful programming paradigm Many computations are naturally self-referential: Mergesort, FFT, gcd, depth-first search Linked data structures A folder contains files and other folders Closely related to mathematical induction Reproductive Parts M. C. Escher,

8 Factorial Recursive Implementation Trace it. int b = factorial(5); 9. static int factorial(int n) { else {

9 Last In First Out (LIFO) Stack of Plates

10 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function Call Stack

11 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function void main(string[] args){ int a = 10; int b = factorial(5); System.out.println(b); Call Stack

12 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function void main(string[] args){ int a = 10; int b = factorial(5); System.out.println(b); Call Stack main() a=10, Line=3

13 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=5) { else { Call Stack n=5, Line=1 main() a=10, Line=3

14 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=5) { else { Call Stack n=5, Line=5 main() a=10, Line=3

15 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=4) { else { Call Stack n=4, Line=1 n=5, Line=5 main() a=10, Line=3

16 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=4) { else { Call Stack n=4, Line=5 n=5, Line=5 main() a=10, Line=3

17 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=3) { else { Call Stack n=3, Line=1 n=4, Line=5 n=5, Line=5 main() a=10, Line=3

18 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=3) { else { Call Stack n=3, Line=5 n=4, Line=5 n=5, Line=5 main() a=10, Line=3

19 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=2) { else { Call Stack n=2, Line=1 n=3, Line=5 n=4, Line=5 n=5, Line=5 main() a=10, Line=3

20 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=2) { else { Call Stack n=2, Line=5 n=3, Line=5 n=4, Line=5 n=5, Line=5 main() a=10, Line=3

21 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=1) { else { Call Stack n=1, Line=1 n=2, Line=5 n=3, Line=5 n=4, Line=5 a=5, Line=5 main() a=10, Line=3

22 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=1) { else { Call Stack n=1, Line=3 n=2, Line=5 n=3, Line=5 n=4, Line=5 a=5, Line=5 main() a=10, Line=3

23 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=2) { else { 1; Call Stack n=2, f=2, Line=6 n=3, Line=5 n=4, Line=5 n=5, Line=5 main() a=10, Line=3

24 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=3) { else { 2; Call Stack n=3, f=6, Line=6 n=4, Line=5 n=5, Line=5 main() a=10, Line=3

25 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=4) { else { 6; Call Stack n=4, f=24, Line=6 n=5, Line=5 main() a=10, Line=3

26 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function int factorial(int n=5) { else { 24; Call Stack n=5, f=120, Line=6 main() a=10, Line=3

27 Compiled Code public static void main (String[] args) { int a = 10; int b = factorial(5); System.out.println(b); static int factorial(int n) { else { Executing Function void main(string[] args){ int a = 10; int b = 120; System.out.println(b); Call Stack main() a=10, b=120, Line=4

28 The Call Stack keeps track of all functions that are suspended, in order the point in the function where execution should resume after the invoked subordinate function returns a snapshot of all variables and values within the scope of the suspended function so these can be restored upon continuing execution. When the subordinate function returns, we need this information in order to continue with computation. The concept of a call stack is not limited to recursion. The same thing happens even when function A calls function B.

29 Towers of Hanoi

30 Towers of Hanoi Move all the discs from the leftmost peg to the rightmost one. Only one disc may be moved at a time. A disc can be placed either on empty peg or on top of a larger disc. start finish Edouard Lucas (1883) 31

31 Towers of Hanoi Legend Q. Is world going to end (according to legend)? 64 golden discs on 3 diamond pegs. World ends when certain group of monks accomplish task. Q. Will computer algorithms help? 32

32 Towers of Hanoi: Recursive Solution Move n-1 smallest discs right. Move largest disc left. cyclic wrap-around Move n-1 smallest discs right. 33

33 Towers of Hanoi: Recursive Solution public class TowersOfHanoi { public static void moves(int n, boolean left) { if (n == 0) return; moves(n-1,!left); if (left) System.out.println(n + " left"); else System.out.println(n + " right"); moves(n-1,!left); public static void main(string[] args) { int N = Integer.parseInt(args[0]); moves(n, true); moves(n, true) : move discs 1 to n one pole to the left moves(n, false): move discs 1 to n one pole to the right smallest disc 34

34 Towers of Hanoi: Recursive Solution % java TowersOfHanoi 3 left right left left left right left every other move is smallest disc So how long will it take the monks to finish their task?? % java TowersOfHanoi 4 right left right right right left right left right left right right right left right subdivisions of ruler 35

35 Towers of Hanoi: Recursion Tree n, left 3, true , false , true left 2, false , true right , true 1, true left 21 3 left left right left 36

36 Recursive Graphics

37 L-systems

38 L-systems

39 L-systems void drawtree(int x, int y, double angle, int depth) { // base case (x + cos(angle) * length, y + sin(angle) * length) // compute end coordinate (x2, y2) // (with length = depth * scalefactor) // draw tree recursively angle (x,y) leftδangle angle (x,y) rightδangle

40 L-systems void drawtree(int x, int y, double angle, int depth) { // base case (x + cos(angle) * length, y + sin(angle) * length) // compute end coordinate (x2, y2) // (with length = depth * scalefactor) // draw tree recursively line (x, y, x2, y2) drawtree(x2, y2, angle leftδangle, depth 1); drawtree(x2, y2, angle + rightδangle, depth 1); angle (x,y) leftδangle angle (x,y) rightδangle

41 L-systems static double scale = 0; static double leftdeltaangle = 15; static double rightdeltaangle = 15; static int recursivedepth = 10; static void drawtree(int x, int y, double angle, int depth) { // base case if (depth == 0) return; (x + cos(angle) * length, y + sin(angle) * length) angle (x,y) // compute end coordinate double angleradians = Math.toRadians(angle); int x2 = x + (int) (Math.cos(angleRadians) * depth * scale); int y2 = y + (int) (Math.sin(angleRadians) * depth * scale); leftδangle // draw tree recursively StdDraw.line(x, y, x2, y2); drawtree(x2, y2, angle - leftdeltaangle, depth - 1); drawtree(x2, y2, angle + rightdeltaangle, depth - 1); angle (x,y) rightδangle

42 L-systems static double scale = 0; static double leftdeltaangle = 15; static double rightdeltaangle = 15; static int recursivedepth = 10; static void drawtree(int x, int y, double angle, int depth) { // base case if (depth == 0) return; public static void setup() { StdDraw.setXscale(0,100); StdDraw.setYscale(0,100); // compute end coordinate double angleradians = Math.toRadians(angle); int x2 = x + (int) (Math.cos(angleRadians) * depth * scale); int y2 = y + (int) (Math.sin(angleRadians) * depth * scale); // draw one frame of animation public static void draw() { drawtree(50, 0, 90, recursivedepth); // draw tree recursively StdDraw.line(x, y, x2, y2); drawtree(x2, y2, angle - leftdeltaangle, depth - 1); drawtree(x2, y2, angle + rightdeltaangle, depth - 1);

43 Htree H-tree of order n. and half the size Draw an H. Recursively draw 4 H-trees of order n-1, one connected to each tip. tip size order 1 order 2 order 3 54

44 55

45 Taplin Auditorium Ventilation System 56

46 Animated H-tree Animated H-tree. Pause for 1 second after drawing each H. 20% 40% 60% 80% 100% 57

47 Htree in Java public class Htree { public static void draw(int n, double sz, double x, double y) { if (n == 0) return; double x0 = x - sz/2, x1 = x + sz/2; double y0 = y - sz/2, y1 = y + sz/2; StdDraw.line(x0, y, x1, y); StdDraw.line(x0, y0, x0, y1); StdDraw.line(x1, y0, x1, y1); draw the H, centered on (x, y) draw(n-1, draw(n-1, draw(n-1, draw(n-1, recursively draw 4 half-size Hs sz/2, sz/2, sz/2, sz/2, x0, x0, x1, x1, y0); y1); y0); y1); public static void main(string[] args) { int n = Integer.parseInt(args[0]); draw(n,.5,.5,.5); 58

48 Fractional Brownian Motion

49 Fractional Brownian Motion Physical process which models many natural and artificial phenomenon. Price of stocks. Dispersion of ink flowing in water. Rugged shapes of mountains and clouds. Fractal landscapes and textures for computer graphics. 70

50 Simulating Brownian Motion Midpoint displacement method. Maintain an interval with endpoints (x0, y0) and (x1, y1). Divide the interval in half. Choose at random from Gaussian distribution. Set xm = (x0 + x1)/2 and ym = (y0 + y1)/2 +. Recur on the left and right intervals. 71

51 Simulating Brownian Motion: Java Implementation Midpoint displacement method. Maintain an interval with endpoints (x0, y0) and (x1, y1). Divide the interval in half. Choose at random from Gaussian distribution. Set xm = (x0 + x1)/2 and ym = (y0 + y1)/2 +. Recur on the left and right intervals. public static void curve(double x0, double y0, double x1, double y1, double var) { if (x1 - x0 < 0.01) { StdDraw.line(x0, y0, x1, y1); return; double xm = (x0 + x1) / 2; double ym = (y0 + y1) / 2; ym += StdRandom.gaussian(0, Math.sqrt(var)); curve(x0, y0, xm, ym, var/2); variance halves at each level; curve(xm, ym, x1, y1, var/2); change factor to get different shapes 72

52 Plasma Cloud Plasma cloud centered at (x, y) of size s. Each corner labeled with some grayscale value. Divide square into four quadrants. The grayscale of each new corner is the average of others. center: average of the four corners + random displacement others: average of two original corners Recur on the four quadrants. c c 1 c1 2 c2 2 c1 c3 2 c2 c4 2 (c1 c 2 c 3 c 4 ) 4 c3 c3 c4 2 c4 73

53 Plasma Cloud 74

54 Brownian Island 75

55 Brownian Landscape Reference: 76