Meljun Cortes Data Structures Recursion

8/21/2019 Meljun Cortes Data Structures Recursion

1/19

Data Structures

Recursion

technique in programming that calls itself

has the capability to save the condition it was inor the particular process it was serving when

calling itself

The design of a recursive method consists ofthe following elements:

One or more stopping conditions that can

Recursion * Property of STI Page 1 of 19

.

One or more recursive steps , in which acurrent value of the method can be

computed by repeated calling of the methodwith arguments that will eventually arrive at

a stopping condition

Two classes of recursion

Direct Recursion

Indirect Recursion


2/19

Data Structures

Recursion

Recursion is viewed as a somewhat mysticaltechnique which is only useful for some very

special class of problems

Can be written using

Assignment statement

If-else statement

While statement


an a so e wr en us ng

o Assignment statement

o If-else statemento recursion


3/19

Data Structures

Triangular Numbers

the sum of 1 to n numbers arranged inequilateral triangle

seen by row where each row is longer than the

previous row

the sum of consecutive integers


Total = 6


4/19

Data Structures

Triangular Numbers

int triangle(int n)

{

int total = 0;

while(n > 0) // until n

is 1{

total = total + n; // add n

(column height) to total


--n; // decrement

column height

}return total;

}

Finding the Nth term using Recursion

The first (tallest) column, which has the value of

n. The sum of all the remaining columns.


5/19

Data Structures

Triangular Numbers

To find the remaining column:

int triangle(int n)

{

return (n +

sumRemainingColumns(n));}

find the sum of all the remaining columns for


term n:

int triangle(int n)

{

return(n + sumAllColumns(n-1));

}

Instead

int triangle(n)

{

return(n + triangle(n-1));

}


6/19

Data Structures

Triangular Numbers



7/19

Data Structures

Triangular Numbers

Recursive algorithm

There must be at least one case (the basecase), for a small value of n that can be

solved directly

A problem of a given size n can be split intoone or more smaller versions of the sameproblem

Identify the base case and provide asolution to it


Create a strategy to split the problem intosmaller versions of itself while making

progress toward the base case Merge the solution that will solve the larger

problem


8/19

Data Structures

Factorial

It is the product of a series of consecutivepositive integers from 1 to a given number, n

Expressed by the symbol !

Number Calculation Factorial0 By definition 1

1 1 * 1 1


Factorial of 6

2 2 * 1 2

3 3 * 2 6

4 4 * 6 24

5 5 * 24 120

6 6 * 120 720


9/19

Data Structures

Anagrams

forming of real English word using the sameletters, no more, no less, the process is calledanagramming

Farm Armf Rmfa Mfar

Famr Arfm Rmaf Mfra


Anagram of the word “Farm”

Frma Amfr Rfam Marf

Fram Amrf Rfma Mafr

Fmar Afrm Ramf Mrfa

Fmra Afmr Rafm Mraf


10/19

Data Structures

Anagrams

Algorithm to anagram a word

Anagram the rightmost n-1 letters

Rotate all n letters

Repeat these steps n time


Rotating a word


11/19

Data Structures

Anagrams

public static void rotate(int newSize)

{

int i;

int position = size - newSize;

// save first letterchar temp = charArray[position];

//shift others left

for (i = position + 1; i < size;


i++)

charArray[i - 1] = charArray[i];

//put first on right

charArray[i - 1] = temp;


12/19

Data Structures

Recursive Binary Search

Algorithm for recursive binary search

Search in the array A in positions numberedloIndex to hiIndex inclusive, for the specified

value

If the value is found, return the index in thearray where it occurs.

If the value is not found, return -1

Precondition: The array must be sorted into



13/19

Data Structures

Towers of Hanoi

invented by Edouard Lucas in 1883

its objective is to transfer the entire tower to thelast peg, moving only one disk at a time without

moving a larger one onto a smaller



14/19

Data Structures

Towers of Hanoi

Algorithm for Towers of Hanoi

Move the smaller disc from the top n-1 from A toB

Move the remaining (larger) disc from A to C

Move the smaller disc from B to C



15/19

Data Structures

Towers of Hanoi



16/19

Data Structures

Towers of Hanoi

doTowers(int topN, char from, char inter,

char to)

{

if(topN==1)

System.out.println("Disc 1 from "

+ from + " to " + to);

else

{

doTowers(topN-1, from, to,


nter ; rom--> nter

System.out.println("Disc " +

topN + "from " + from + "to " + to);

doTowers(topN-1, inter, from,

to); // inter-->to

}

}


17/19

Data Structures

Mergesort

requires another array in the memory

Algorithm for mergesort

Divide the list into two, with your desiredsize

Sort the first and second list Megre the two sublists into one sorted list



18/19

Data Structures

Mergesort

Step Comparison Copy

1 Compare 12 and 8 Copy 8 from arr1 to arr3





Merging Process






11 Copy 89 from arr1 to arr3


19/19

Data Structures

Types of Recursion

Linear Recursion

Tail Recursion

Binary Recursion

Exponential Recursion

Nested Recursion

Mutual Recursion


Depth of Recursion

number of times the procedure is called

recursively in the process of evaluating agiven argument

Documents

Meljun Cortes Data Structures Recursion