Recursion: Function and Programming Software Engineering at Azusa Pacific University Evolutionary Approach Examples and Algorithms Programming in

Recursion: Function and ProgrammingRecursion: Function and Programming

Software Engineering at Software Engineering at Azusa Pacific UniversityAzusa Pacific University

Evolutionary Approach

Examples and Algorithms

Programming in C++

Recursion and Iteration

Summary

This is an example in regard to programming and algorithm. Here I took part of material from my previous teaching.

April 19, 20231

Azusa Pacific University, Azusa, CA 91702, Tel: (800) 825-5278 Department of Computer Science, http://www.apu.edu/clas/computerscience/

http://www.apu.edu/clas/computerscience/

Evolutionary Approach (Present = Past + Span)

Let’s learn from math (break-down / gather-up)Span Solvable

Unsolved

= = +

Present Past

= = +

= = +

Break-

down

Gather-

up



April 19, 20232



With recursively thinking and programming, we do break-down-into-past first, then gather-up-to-present

funcT RunBack (T timeTag) { if (bEarlyEnough(timeTag)) // termination

return Answer; else // recursive approach

return RunBack (DeTimeTag) + Span (timeTag); }

A function calls to itself (directly or indirectly)



Examples and Algorithms (typical pattern)

April 19, 20233



Examples and Algorithms (Factorial)

/* Fact = 1 * 2 * (i-1) * i * … 8 * * Fact (i) = Fact(i-1) * i * * Past Span

Assume we need to do factorial. We use the number as time tag, so that i refers to the present while i-1 to the previous (or past). The recursive function calling itself fulfils recursion



*==== How the recursion works is described as follows ===== * Fact = Fact(7) * 8 * └ fact(6) * 7 * └ Fact(5) * 6 * … …. * └ fact(0) *1

8! = (7!)*8 = 40320 7! = (6!)*7 = 5040 6! = (5!)*4 =720

1 */

Gather-

up

Break-

down

April 19, 20234





Programming in C++


Summary



April 19, 20235



Programming in C++ (Factorial)

/* ==== recursive function ======= * !! What a intuitive mapping !! * Fn= Fn-1 * n * * (1) (2) (3) */long Fact (int n) // n is time tag{ if (n == 1) // Termination return n; else // recurring back return Fact (n-1) * n;}

Recall that the Fibonacci numbers are defined recursively: However, the algorithm used in left program is non-recursive --it is iterative, while in right program we use the definition of Fibonacci numbers to implement directly a recursive algorithm.

/*===== iterative implementation === * ?? Where is intuitive definition?? */int IterativeFact (int n){ int previous = -1, result = 0; for (int i=0; I <= n; i++) { int const sum = result + previous; previous = result; result = sum; } return result;}



April 19, 20236





Programming in C++


Summary



April 19, 20237



Life cycle issues (logic equivalence) Tree elements for both iteration and recursion

Initialization / Termination / Decrease/* ======Recursive Process=====*/int main (){ int ret = Fact(8); // Initialization}long Factint n) // n is time tag{ if (i == 1) // Termination return 1; else return Fact(n-1) * n; // Decrease}

/* ===== Iterative Process======*/int main (){ long ret= 1; // Initialization while (n>0) // Termination { ret *= n; n--; // Decrease }}

Recursion and IterationRecursion: Function and ProgrammingRecursion: Function and Programming


April 19, 20238



Life cycle issues (logic equivalence) Logic equivalent solution (I/T/D)



/* General recursive function * Fn = Fn-1 + Sn

* *========= * Fact = Fact(7) * 8 * └ fact(6) * 7 * └ Fact(5) * 6 * └ Fact(4) * 5 * └ Fact(3) * 4 * └ Fact(2) * 3 * └ Fact(1) * 2 * └ 1 *1 8

7

6

5

4

3

2 = 40320

= 5040

= 720

= 120

= 24

= 6

= 2

= 1

23

4

5

6

7

8

Break down to past Gather up to present

April 19, 20239






/* General recursive function * Fn = Fn-1 + Sn

* =========Long ret = 1for (i=8; I > 0; i--) { // descending to past push (I, stack)}For (i=8; i > 0; i --){ // ascending to present ret *= pop (stack)} 8

7

6

5

4

3

2= 40320

= 5040

= 720

= 120

= 24

= 6

= 2

= 1

23

4

5

6

7

8

April 19, 202310






By means of stack, we can always find a iterative equivalence to any recursive algorithm. However some iterative solution will be very difficult to understand, because it loses straightforwardness

April 19, 202311



Simplified thought (KISS) Inefficient running (procedural call) Straightforward (intuitive in math)

Life cycle issues (Initialization / Termination / Decrease) Tricky exercise between recursion and iteration

Iteration provides plane algorithm Complicated thinking thread Efficient running (just iteratively going through) Non-straightforward in description (twisty)

Recursion provides solid algorithm



April 19, 202312


Life cycle issues (Initialization / Termination / Decrease) Tricky exercise between recursion and iteration Mechanical conversion from recursion to iteration

Converted by compilers and algorithm designer Keep it simplified (for man to write) Auto complicated (for machine to convert) Efficiency improved (for application)

Go do right thing with recursive design because keeping it simple is really wise, while taking advantage of computer for conversion if necessary



April 19, 202313




Programming in C++


Summary



April 19, 202314


Summary of Recursion

Recursive thinking: Mathematic intuition (straightforwardness) Be wise: looking back prior to looking ahead

Recursive programming Function calls itself, directly or indirectly Remember this: the past is the key to the present

Recurring back: If complicated, break down to past Conquer the parts, then gather up to present



April 19, 202315



April 19, 202316


Documents

Recursion: Function and Programming Software Engineering at Azusa Pacific University Evolutionary Approach Examples and Algorithms Programming in