Scribd
Upload
40 views

Procedural Recursion: Eric Roberts CS 106B April 15, 2009

The document discusses procedural recursion through examples. It explains that recursion involves dividing a problem into smaller subproblems of the same type. A fundraising example is used to illustrate how a goal can be broken down recursively into smaller goals. The Towers of Hanoi problem is also presented to demonstrate how a recursive solution works by breaking the problem into base cases and smaller instances of the same problem type.

Uploaded by

Kimberly Scott
Copyright
© Attribution Non-Commercial (BY-NC)
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
40 views

Procedural Recursion: Eric Roberts CS 106B April 15, 2009

The document discusses procedural recursion through examples. It explains that recursion involves dividing a problem into smaller subproblems of the same type. A fundraising example is used to illustrate how a goal can be broken down recursively into smaller goals. The Towers of Hanoi problem is also presented to demonstrate how a recursive solution works by breaking the problem into base cases and smaller instances of the same problem type.

Uploaded by

Kimberly Scott
Copyright
© Attribution Non-Commercial (BY-NC)
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/ 14

Procedural Recursion

Eric Roberts CS 106B April 15, 2009

Recursion
One of the most important Great Ideas in CS 106B is the concept of recursion, which is the process of solving a problem by dividing it into smaller subproblems of the same form. The italicized phrase is the essential characteristic of recursion; without it, all you have is a description of stepwise refinement of the sort we teach in CS 106A. The fact that recursive decomposition generates subproblems that have the same form as the original problem means that recursive programs will use the same function or method to solve subproblems at different levels of the solution. In terms of the structure of the code, the defining characteristic of recursion is having functions that call themselves, directly or indirectly, as the decomposition process proceeds.

A Simple Illustration of Recursion


Suppose that you are the national fundraising director for a charitable organization and need to raise $1,000,000. One possible approach is to find a wealthy donor and ask for a single $1,000,000 contribution. The problem with that strategy is that individuals with the necessary combination of means and generosity are difficult to find. Donors are much more likely to make contributions in the $100 range. Another strategy would be to ask 10,000 friends for $100 each. Unfortunately, most of us dont have 10,000 friends. There are, however, more promising strategies. You could, for example, find ten regional coordinators and charge each one with raising $100,000. Those regional coordinators could in turn delegate the task to local coordinators, each with a goal of $10,000, continuing the process reached a manageable contribution level.

A Simple Illustration of Recursion


The following diagram illustrates the recursive strategy for raising $1,000,000 described on the previous slide:
Goal: $1,000,000

Goal: Goal: Goal: Goal: Goal: Goal: Goal: Goal: Goal: Goal: $100,000 $100,000 $100,000 $100,000 $100,000 $100,000 $100,000 $100,000 $100,000 $100,000

Goal: $10,000

Goal: $10,000

Goal: $10,000

Goal: $10,000

Goal: $10,000

Goal: $10,000

Goal: $10,000

Goal: $10,000

Goal: $10,000

Goal: $10,000

Goal: $1000

Goal: $1000

Goal: $1000

Goal: $1000

Goal: $1000

Goal: $1000

Goal: $1000

Goal: $1000

Goal: $1000

Goal: $1000

Goal: $100

Goal: $100

Goal: $100

Goal: $100

Goal: $100

Goal: $100

Goal: $100

Goal: $100

Goal: $100

Goal: $100

A Pseudocode Fundraising Strategy


If you were to implement the fundraising strategy in the form of a C++ function, it would look something like this:
void CollectContributions(int n) { if (n <= 100) { Collect the money from a single donor. } else { Find 10 volunteers. Get each volunteer to collect n/10 dollars. Combine the money raised by the volunteers. } }

What makes this strategy recursive is that the line


Get each volunteer to collect n/10 dollars.

will be implemented using the following recursive call:


CollectContributions(n / 10);

The Towers of Hanoi Solution


int main() { int MoveTower(int nDisks = 3; n, char start, char finish, char temp) { void InitHanoiGraphics(nDisks); if (n == 1) { void MoveTower(int n, char start, char finish, char temp) { MoveTower(nDisks, 'A', 'B', 'C'); MoveSingleDisk(start, finish); if (n == 1) { void MoveTower(int n, char start, char finish, char temp) { nDisks return 0; } else { MoveSingleDisk(start, finish); if (n == 1) { } 3 MoveTower(n 1, start, temp, finish); } else { MoveSingleDisk(start, finish); MoveSingleDisk(start, finish); MoveTower(n 1, start, temp, finish); } else { MoveTower(n - 1, temp, finish, start); MoveSingleDisk(start, finish); MoveTower(n 1, start, temp, finish); } n start finish temp MoveTower(n - 1, temp, finish, start); MoveSingleDisk(start, finish); } 'C' 'B' 'A' start); } 3 n temp, start finish temp MoveTower(n - 1, finish, } 'B' 'A' 'C' 'B' 'A' 'C' } n 2 start finish temp } 'A' 'B' 'C' 'C' 'A' 'B' 'B' 'C' 'A' 1
Hanoi

skip simulation

The Recursive Leap of Faith


The purpose of going through the complete decomposition of the Towers of Hanoi problem is to convince you that the process works and that recursive calls are in fact no different from other method calls, at least in their internal operation. The danger with going through these details is that it might encourage you to do the same when you write your own recursive programs. As it happens, tracing through the details of a recursive program almost always makes such programs harder to write. Writing recursive programs becomes natural only after you have enough confidence in the process that you dont need to trace them fully. As you write a recursive program, it is important to believe that any recursive call will return the correct answer as long as the arguments define a simpler subproblem. Believing that to be trueeven before you have completed the codeis called the recursive leap of faith.

The Recursive Paradigm


Most recursive methods you encounter in an introductory course have bodies that fit the following general pattern:
if (test for a simple case) { Compute and return the simple solution without using recursion. } else { Divide the problem into one or more subproblems that have the same form. Solve each of the problems by calling this method recursively. Return the solution from the results of the various subproblems. }

Finding a recursive solution is mostly a matter of figuring out how to break it down so that it fits the paradigm. When you do so, you must do two things:
1. Identify simple cases that can be solved without recursion. 2. Find a recursive decomposition that breaks each instance of the problem into simpler subproblems of the same type, which you can then solve by applying the method recursively.

Graphical Recursion
Recursion comes up in certain graphical applications, most notably in the creation of fractals, which are mathematical structures that consist of similar figures repeated at various different scales. Fractals were popularized in a 1982 book by Benoit Mandelbrot entitled The Fractal Geometry of Nature.

One of the simplest fractal patterns to draw is the Koch fractal, named after its inventor, the Swedish mathematician Helge von Koch (1870-1924). The Koch fractal is sometimes called a snowflake fractal because of the beautiful, six-sided symmetries it displays as the figure becomes more detailed. as illustrated in the following diagram:

Methods in the Graphics Library


InitGraphics()
Initializes the graphics library and clears the graphics window.

MovePen(x, y)
Moves the drawing pen to the point (x, y) without drawing a line.

DrawLine(dx, dy)
Draws a line from the current point using the displacements dx and dy.

GetWindowWidth()
Returns the width of the graphics window.

GetWindowHeight()
Returns the height of the graphics window.

SetCoordinateSystem(system)
Sets the coordinate system to "screen" or "cartesian".

DrawPolarLine
The Koch snowflake fractal is much easier to write if you use polar coordinates, in which each line segment is specified in terms of its length (r) and its angle from the origin (), as illustrated in the following diagram:
r

Fortunately, this model is easy to implement:


const double PI = 3.1415926535; void DrawPolarLine(double r, double theta) { double radians = theta / 180 * PI; DrawLine(r * cos(radians), r * sin(radians)); }

How Long is the Coast of England?


The first widely circulated paper about fractals was a 1967 article in Science by Mandelbrot that asked the seemingly innocuous question, How long is the coast of England? The point that Mandelbrot made in the article is that the answer depends on the measurement scale, as these images from Wikipedia show.

This thought-experiment serves to illustrate the fact that coastlines are fractal in that they exhibit the same structure at every level of detail.
200km 100km 50km ruler

Exercise: Fractal Coastline


Exercise 14 on page 263 asks you to draw a fractal coastline between two points, A and B, on the graphics window.
The order-0 coastline is just a straight line. The order-1 coastline replaces that line with one containing a triangular wedge pointing randomly up or down. The order-2 coastline does the same for each line in the order-1. Repeating this process eventually yields an order-5 coastline.
Coastline

The End

You might also like