JW
Uploaded byJames Wong
PPT, PDF949 views

Recursion

Recursion involves functions that call themselves during execution. This document discusses recursive functions like factorial, Fibonacci sequence, power, and printing patterns. Recursive functions have a base case that stops the recursion. The factorial function is defined recursively as n! = n * (n-1)!, and this recursive definition is evaluated step-by-step for fact(4). Recursive functions can also be used to define sequences like Fibonacci numbers.

Embed presentation

Downloaded 51 times
Recursion
Functions – reminder A function can call other functions. Return causes the execution of the function to terminate and returns a value to the calling function. The type of the value returned must be the same as the return-type defined for the function. return-type name(argType1 arg1, argType2 arg2, …) { function body; return value; }
A recursive definition C functions can also call themselves!  However, usually not with the same parameters (why?) Some functions can be defined using smaller occurrences of themselves. Such a definition is called a “recursive definition” of a function.
Recursive calling Example: void func(int n){ putchar(`*`); func(n); } Infinite series of * What is the problem ? Look for other problem …
Factorial By definition : n! = 1*2*3*… *(n-1)*n Thus, we can also define factorial the following way:  0! = 1  n! = n*(n-1)! for n>0 (n-1)! *n
Example - factorial int factRec(int n){ if (n==0 || n==1) return 1; return n*factRec(n-1); } int factorial(int n){ int fact = 1; while (n >= 1) { fact *=n; n--; } return fact; }
Conclusions for Recursive calling Every recursive function has a “boundary condition”. The function stops calling itself when it is satisfied.
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… 4*…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… 3*…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… 2*…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… FactRec(1) n 1 Returns…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… FactRec(1) n 1 Returns…
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… FactRec(1) n 1 Returns… 1
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… 2*1
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… 3*2
Recursive factorial – step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… 4*6
1 #include <stdio.h> void print1(int n){ if (n>=0){ printf("%d ",n); print1(n-1); { { void main(){ int i = 3; print1(i); putchar('n'); { 3 2 1 0
2 #include <stdio.h> void print2(int n){ if (n>=0){ print2(n-1); printf("%d ",n); { { void main(){ int i = 3; print2(i); putchar('n'); { 0 1 2 3
3 #include <stdio.h> void print3(int n){ if (n>=0){ printf("%d ",n); print3(n-1); printf("%d ",n); { { void main(){ int i = 3; print3(i); putchar('n'); { 3 2 1 0 0 1 2 3
4 #include <stdio.h> void print4(int n){ if (n>=0){ print4(n-1); printf("%d ",n); print4(n-1); { { void main(){ int i = 3; print4(i); putchar('n'); { 0 1 0 2 0 1 0 3 0 1 0 2 0 1 0
Another example - power  X y = x*x*…*x  Recursive definitions (assume non-negative y):  Base: x0 =1 1. X y = X*(X y-1 ) 2. X y =(X y/2 ) 2 (for even y’s only) y times
Fibonacci Series Fibonacci definition:  n0 = 0  n1 = 1  nn = nn-1 + nn-2 0 1 1 2 3 5 8 13 21 34 55 …
Fibonacci Iterative void fibonacci(int n) { int Fn, Fn1, Fn2, ind; Fn2 = 0 ; Fn1 = 1 ; Fn = 0 ; if ( n == 1 ) Fn = 1 ; for (ind=2 ; ind <= n ; ind++){ Fn = Fn1 + Fn2; Fn2 = Fn1; Fn1 = Fn; } printf("F(%d) = %d n", n, Fn); }
Fibonacci Recursive fibonacci(1) fibonacci(5) fibonacci(4) fibonacci(3) fibonacci(3) fibonacci(2) fibonacci(2) fibonacci(1) fibonacci(2) fibonacci(1) fibonacci(1) fibonacci(0) fibonacci(0) fibonacci(1) fibonacci(0) int fibonacci(int n) { if (n==0) return 0; if (n==1) return 1; return fibonacci(n-1) + fibonacci(n-2); }
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… 2*… y 5
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… y 4
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… y 4
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… y 4
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… y 2
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… y 2
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… y 2
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… y 1
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… y 1
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… y 1
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… y 1
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*… y 1
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*… y 1 rec_pow(2, 0) x 2 Returns… y 0
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*… y 1 rec_pow(2, 0) x 2 Returns… y 0
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*… y 1 rec_pow(2, 0) x 2 Returns… 1 y 0
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*1 y 1
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(2) y 2
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(4) y 4
rec_pow – step by step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… 2*16 y 5
Exercise Write a program that receives two non-negative integers and computes their product recursively. Not * multiple operator !! Hint: Notice that the product a*b is actually a+a+… +a (b times).
Solution int recMult( int x, int y ) { if( x == 0) return 0; return y + recMult( x-1,y); {
Exercise Given the following iterative version of sum-of-digits calculation Find the recursive definition of this function (don’t forget the base case!) int sum_digits(int n){ int sum = 0; while (n > 0) { sum += n%10; n = n/10; } return sum; }
Solution int sumOfDigits( int x ) { if( x < 0) x *= -1; if( x == 0 ) return 0; else return x % 10 + sumOfDigits( x / 10 ); }
More uses Recursion is a general approach to programming functions. Its uses are not confined to calculating mathematical expressions! For example : write a function that finds the max member in an array of integer.
Solution int rec_max(int arr[ ], int size){ int rest; if (size == 1) return arr[0]; else { rest = rec_max(arr+1, size-1); if (arr[0] > rest) return arr[0]; else return rest; } }
int BinarySearch(int arr[],int x, int left, int right) { int middle; if(left>right) return -1; else { middle=(left+right)/2); if(arr[middle]==x) return middle; else if(x < arr[middle]) return BinarySearch(arr,x,left,middle-1); else return BinarySearch(arr,x,middle+1,right); } }
Towers of Hanoi The Towers of Hanoi problem consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape. The objective of the puzzle is to move the entire stack to another rod, obeying the following rules:  Only one disk may be moved at a time.  Each move consists of taking the upper disk from one of the rods and sliding it onto another rod, on top of the other disks that may already be present on that rod.  No disk may be placed on top of a smaller disk.
Towers of Hanoi
Recursive Solution To move n disks from peg A to peg C:  move n−1 disks from A to B. This leaves disk #n alone on peg A  move disk #n from A to C  move n−1 disks from B to C so they sit on disk #n
Recursive Solution - Function void hanoi(int x, char from, char to, char aux){ if(x==1){ printf("Move Disk From %c to %cn", from, to); } else { hanoi(x-1,from,aux,to); printf("Move Disk From %c to %cn", from, to); hanoi(x-1,aux,to,from); } }
Scope of variables - reminder A variable declared within a function is unrelated to variables declared elsewhere. A function cannot access variables that are declared in other functions.

More Related Content

PPTX
Recursion
bySsankett Negi
 
PPT
Data Structures- Part5 recursion
byAbdullah Al-hazmy
 
PPTX
Recursion
bybaabtra.com - No. 1 supplier of quality freshers
 
PDF
Iterations and Recursions
byAbdul Rahman Sherzad
 
PPT
Recursion
byMalainine Zaid
 
PPTX
Recursion
byAbdur Rehman
 
PDF
Introduction to Recursion (Python)
byThai Pangsakulyanont
 
PPT
Ch10 Recursion
byleminhvuong
 
Recursion
bySsankett Negi
 
Data Structures- Part5 recursion
byAbdullah Al-hazmy
 
Recursion
bybaabtra.com - No. 1 supplier of quality freshers
 
Iterations and Recursions
byAbdul Rahman Sherzad
 
Recursion
byMalainine Zaid
 
Recursion
byAbdur Rehman
 
Introduction to Recursion (Python)
byThai Pangsakulyanont
 
Ch10 Recursion
byleminhvuong
 

What's hot

PPS
Let Us Learn Lambda Using C# 3.0
bySheik Uduman Ali
 
PPTX
Recursion(Advanced data structure)
bykurubameena1
 
PPTX
Lecture09 recursion
byHariz Mustafa
 
PDF
CPSC 125 Ch 2 Sec 4
byDavid Wood
 
PPT
Primitive Recursive Functions
byRadhakrishnan Chinnusamy
 
PPT
functions
byGaditek
 
PPTX
5.2 primitive recursive functions
bySampath Kumar S
 
PPTX
Asymptotic Notation
byProtap Mondal
 
PDF
01. design & analysis of agorithm intro & complexity analysis
byOnkar Nath Sharma
 
PPTX
Mathematical Analysis of Recursive Algorithm.
bymohanrathod18
 
PPT
Induction
byLal Bdr. Saud
 
PPT
Algorithm.ppt
byTareq Hasan
 
PDF
Advanced C - Part 3
byEmertxe Information Technologies Pvt Ltd
 
PPTX
Control System Homework Help
byMatlab Assignment Experts
 
PDF
6-Python-Recursion.pdf
byAshishPalandurkar2
 
PDF
Divide and Conquer
byMohammed Hussein
 
PDF
Algorithm chapter 2
bychidabdu
 
PDF
Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala
byPhilip Schwarz
 
PPT
Arrays
byarchikabhatia
 
PPTX
Functions
byPralhadKhanal1
 
Let Us Learn Lambda Using C# 3.0
bySheik Uduman Ali
 
Recursion(Advanced data structure)
bykurubameena1
 
Lecture09 recursion
byHariz Mustafa
 
CPSC 125 Ch 2 Sec 4
byDavid Wood
 
Primitive Recursive Functions
byRadhakrishnan Chinnusamy
 
functions
byGaditek
 
5.2 primitive recursive functions
bySampath Kumar S
 
Asymptotic Notation
byProtap Mondal
 
01. design & analysis of agorithm intro & complexity analysis
byOnkar Nath Sharma
 
Mathematical Analysis of Recursive Algorithm.
bymohanrathod18
 
Induction
byLal Bdr. Saud
 
Algorithm.ppt
byTareq Hasan
 
Advanced C - Part 3
byEmertxe Information Technologies Pvt Ltd
 
Control System Homework Help
byMatlab Assignment Experts
 
6-Python-Recursion.pdf
byAshishPalandurkar2
 
Divide and Conquer
byMohammed Hussein
 
Algorithm chapter 2
bychidabdu
 
Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala
byPhilip Schwarz
 
Arrays
byarchikabhatia
 
Functions
byPralhadKhanal1
 

Similar to Recursion

PDF
062636636366363773737373733+73737733+7.pdf
byGauravKumar295392
 
PPTX
06 Recursion in C.pptx
byMouDhara1
 
PDF
Recursion examples
byHafsaZahran
 
PDF
Recursion.pdf
byFlavia Tembo Kambale
 
PPTX
Recursion
byKasun Ranga Wijeweera
 
PPTX
RecursionRecursionRecursionRecursion.pptx
byp8441025460
 
PPT
Lec-32 Recursion - Divide and Conquer in Queue
byAnil Yadav
 
PPT
14 recursion
byHimadri Sen Gupta
 
PPT
lecture 10 Recursive Function and Macros.ppt
byAbhishekkumarsingh630054
 
PDF
Chapter VII RECURSION.pdf algor and data structure
bybenyakoubrania53
 
PPT
Basic_analysis.ppt
bySoumyaJ3
 
PPT
Design and analysis of algorithms-chapter1.ppt
byDrSamsonChepuri1
 
PPT
chapter1.ppt
bySankarTerli
 
PPT
chapter1.ppt
bychetanvchaudhari
 
PDF
7-IntroToRecursionprgramminginc++course.pdf
byFantaneshTegegn1
 
PDF
3_Recursionyurvkkbyukybkfyfkbluyftru6v5444444444446.pdf
byNusky5
 
PPT
recursion functions in programming languages
byabeerqashou1
 
PPTX
call_by_value_and_reference-Recursion_function.pptx
bybabar801420
 
PPTX
Introduction to Dynamic Programming.pptx
byPochupouOwo
 
PPT
Lec-6 Recursion of Data Structures & Algorithms
byhaseebanjum2611
 
062636636366363773737373733+73737733+7.pdf
byGauravKumar295392
 
06 Recursion in C.pptx
byMouDhara1
 
Recursion examples
byHafsaZahran
 
Recursion.pdf
byFlavia Tembo Kambale
 
Recursion
byKasun Ranga Wijeweera
 
RecursionRecursionRecursionRecursion.pptx
byp8441025460
 
Lec-32 Recursion - Divide and Conquer in Queue
byAnil Yadav
 
14 recursion
byHimadri Sen Gupta
 
lecture 10 Recursive Function and Macros.ppt
byAbhishekkumarsingh630054
 
Chapter VII RECURSION.pdf algor and data structure
bybenyakoubrania53
 
Basic_analysis.ppt
bySoumyaJ3
 
Design and analysis of algorithms-chapter1.ppt
byDrSamsonChepuri1
 
chapter1.ppt
bySankarTerli
 
chapter1.ppt
bychetanvchaudhari
 
7-IntroToRecursionprgramminginc++course.pdf
byFantaneshTegegn1
 
3_Recursionyurvkkbyukybkfyfkbluyftru6v5444444444446.pdf
byNusky5
 
recursion functions in programming languages
byabeerqashou1
 
call_by_value_and_reference-Recursion_function.pptx
bybabar801420
 
Introduction to Dynamic Programming.pptx
byPochupouOwo
 
Lec-6 Recursion of Data Structures & Algorithms
byhaseebanjum2611
 

More from James Wong

PPT
Data race
byJames Wong
 
PPT
Multi threaded rtos
byJames Wong
 
PPTX
Business analytics and data mining
byJames Wong
 
PPTX
Data mining and knowledge discovery
byJames Wong
 
PPTX
Cache recap
byJames Wong
 
PPTX
Big picture of data mining
byJames Wong
 
PPTX
How analysis services caching works
byJames Wong
 
PPTX
Optimizing shared caches in chip multiprocessors
byJames Wong
 
PPTX
Directory based cache coherence
byJames Wong
 
PPT
Abstract data types
byJames Wong
 
PPTX
Abstraction file
byJames Wong
 
PPTX
Hardware managed cache
byJames Wong
 
PPTX
Object model
byJames Wong
 
PPT
Abstract class
byJames Wong
 
PPTX
Object oriented analysis
byJames Wong
 
PPTX
Concurrency with java
byJames Wong
 
PPTX
Data structures and algorithms
byJames Wong
 
PPTX
Cobol, lisp, and python
byJames Wong
 
PPTX
Inheritance
byJames Wong
 
PPTX
Api crash
byJames Wong
 
Data race
byJames Wong
 
Multi threaded rtos
byJames Wong
 
Business analytics and data mining
byJames Wong
 
Data mining and knowledge discovery
byJames Wong
 
Cache recap
byJames Wong
 
Big picture of data mining
byJames Wong
 
How analysis services caching works
byJames Wong
 
Optimizing shared caches in chip multiprocessors
byJames Wong
 
Directory based cache coherence
byJames Wong
 
Abstract data types
byJames Wong
 
Abstraction file
byJames Wong
 
Hardware managed cache
byJames Wong
 
Object model
byJames Wong
 
Abstract class
byJames Wong
 
Object oriented analysis
byJames Wong
 
Concurrency with java
byJames Wong
 
Data structures and algorithms
byJames Wong
 
Cobol, lisp, and python
byJames Wong
 
Inheritance
byJames Wong
 
Api crash
byJames Wong
 

Recently uploaded

PDF
January 2026 OpenMetadata Community Spotlight - OpenMetadata @ Wix.pdf
byOpenMetadata
 
PDF
Analyze and Preserve Logs - RHCSA (RH134).pdf
byLinuxCert Guru
 
PDF
Supercharge Your Copilot-Driven Collaboration with Microsoft 365 Agents SDK
byAntti Koskela
 
PDF
UiPath Automation Developer Associate Training Series 2026 - Session 1
byDianaGray10
 
PDF
Chapter 4 Network Security in computer security
byGetnet Tigabie Askale -(GM)
 
PDF
ICT500 - CRITICAL AND CREATIVE THINKING FOR INFORMATION TECHNOLOGY SOLUTIONS:...
by2024432452
 
PDF
Safer’s Picks: The 5 FME Transformers You Didn’t Know You Needed
bySafe Software
 
PPTX
NTG - Data Center Management System Software
byMustafa Kuğu
 
PPTX
Beyond the Algorithm: Designing Human-Centric Public Service with AI
byAlan Dix
 
PPTX
Career-Opportunities in Industrial Arts Grade 8 PPT Lesson 2
byFSBTLEDNathanVince
 
PDF
Post-Hackathon-Learnings-Maximizing-Impact-Beyond-the-Event.pdf
byishantyadav1111
 
PDF
"Painless Major Upgrade: A Strategy for Updating Large Codebases", Andrii Yat...
byFwdays
 
PDF
Computer-Based Training (CBT) The Backbone of Modern Technical & Defence Trai...
bycomputerbasedtrainin1
 
PDF
Writing GPU-Ready AI Models in Pure Java with Babylon
byAna-Maria Mihalceanu
 
PDF
CI CD Observability, Metrics and DORA - Shifting Left and Cleaning Up! - Febr...
byPeter Souter
 
PPTX
2026 SCORM Troubleshooting Rustici + dominKnow.pptx
byRustici Software
 
PDF
Bettersize | BeSEC Series Product Brochure
byBettersize Instruments
 
PDF
What Is the Azure AI Foundry and Why Does It Matter for Enterprises?
byjohncarterjn
 
PDF
The Enterprise Web3 Landscape - a view from Kaleido based on the past 10 year...
byPeter Broadhurst
 
PDF
"When every team does things "right", but together it turns into chaos", Yozh...
byFwdays
 
January 2026 OpenMetadata Community Spotlight - OpenMetadata @ Wix.pdf
byOpenMetadata
 
Analyze and Preserve Logs - RHCSA (RH134).pdf
byLinuxCert Guru
 
Supercharge Your Copilot-Driven Collaboration with Microsoft 365 Agents SDK
byAntti Koskela
 
UiPath Automation Developer Associate Training Series 2026 - Session 1
byDianaGray10
 
Chapter 4 Network Security in computer security
byGetnet Tigabie Askale -(GM)
 
ICT500 - CRITICAL AND CREATIVE THINKING FOR INFORMATION TECHNOLOGY SOLUTIONS:...
by2024432452
 
Safer’s Picks: The 5 FME Transformers You Didn’t Know You Needed
bySafe Software
 
NTG - Data Center Management System Software
byMustafa Kuğu
 
Beyond the Algorithm: Designing Human-Centric Public Service with AI
byAlan Dix
 
Career-Opportunities in Industrial Arts Grade 8 PPT Lesson 2
byFSBTLEDNathanVince
 
Post-Hackathon-Learnings-Maximizing-Impact-Beyond-the-Event.pdf
byishantyadav1111
 
"Painless Major Upgrade: A Strategy for Updating Large Codebases", Andrii Yat...
byFwdays
 
Computer-Based Training (CBT) The Backbone of Modern Technical & Defence Trai...
bycomputerbasedtrainin1
 
Writing GPU-Ready AI Models in Pure Java with Babylon
byAna-Maria Mihalceanu
 
CI CD Observability, Metrics and DORA - Shifting Left and Cleaning Up! - Febr...
byPeter Souter
 
2026 SCORM Troubleshooting Rustici + dominKnow.pptx
byRustici Software
 
Bettersize | BeSEC Series Product Brochure
byBettersize Instruments
 
What Is the Azure AI Foundry and Why Does It Matter for Enterprises?
byjohncarterjn
 
The Enterprise Web3 Landscape - a view from Kaleido based on the past 10 year...
byPeter Broadhurst
 
"When every team does things "right", but together it turns into chaos", Yozh...
byFwdays
 

Recursion

  • 1.
  • 2.
    Functions – reminder Afunction can call other functions. Return causes the execution of the function to terminate and returns a value to the calling function. The type of the value returned must be the same as the return-type defined for the function. return-type name(argType1 arg1, argType2 arg2, …) { function body; return value; }
  • 3.
    A recursive definition Cfunctions can also call themselves!  However, usually not with the same parameters (why?) Some functions can be defined using smaller occurrences of themselves. Such a definition is called a “recursive definition” of a function.
  • 4.
    Recursive calling Example: void func(intn){ putchar(`*`); func(n); } Infinite series of * What is the problem ? Look for other problem …
  • 5.
    Factorial By definition : n!= 1*2*3*… *(n-1)*n Thus, we can also define factorial the following way:  0! = 1  n! = n*(n-1)! for n>0 (n-1)! *n
  • 6.
    Example - factorial intfactRec(int n){ if (n==0 || n==1) return 1; return n*factRec(n-1); } int factorial(int n){ int fact = 1; while (n >= 1) { fact *=n; n--; } return fact; }
  • 7.
    Conclusions for Recursivecalling Every recursive function has a “boundary condition”. The function stops calling itself when it is satisfied.
  • 8.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns…
  • 9.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… 4*…
  • 10.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns…
  • 11.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns…
  • 12.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… 3*…
  • 13.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns…
  • 14.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns…
  • 15.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… 2*…
  • 16.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… FactRec(1) n 1 Returns…
  • 17.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… FactRec(1) n 1 Returns…
  • 18.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… FactRec(1) n 1 Returns… 1
  • 19.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… FactRec(2) n 2 Returns… 2*1
  • 20.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… FactRec(3) n 3 Returns… 3*2
  • 21.
    Recursive factorial –step by step int factRec(int n) { if (n==0 || n==1) return 1; return n*factRec(n-1); } FactRec(4) n 4 Returns… 4*6
  • 22.
    1 #include <stdio.h> void print1(intn){ if (n>=0){ printf("%d ",n); print1(n-1); { { void main(){ int i = 3; print1(i); putchar('n'); { 3 2 1 0
  • 23.
    2 #include <stdio.h> void print2(intn){ if (n>=0){ print2(n-1); printf("%d ",n); { { void main(){ int i = 3; print2(i); putchar('n'); { 0 1 2 3
  • 24.
    3 #include <stdio.h> void print3(intn){ if (n>=0){ printf("%d ",n); print3(n-1); printf("%d ",n); { { void main(){ int i = 3; print3(i); putchar('n'); { 3 2 1 0 0 1 2 3
  • 25.
    4 #include <stdio.h> void print4(intn){ if (n>=0){ print4(n-1); printf("%d ",n); print4(n-1); { { void main(){ int i = 3; print4(i); putchar('n'); { 0 1 0 2 0 1 0 3 0 1 0 2 0 1 0
  • 26.
    Another example -power  X y = x*x*…*x  Recursive definitions (assume non-negative y):  Base: x0 =1 1. X y = X*(X y-1 ) 2. X y =(X y/2 ) 2 (for even y’s only) y times
  • 27.
    Fibonacci Series Fibonacci definition: n0 = 0  n1 = 1  nn = nn-1 + nn-2 0 1 1 2 3 5 8 13 21 34 55 …
  • 28.
    Fibonacci Iterative void fibonacci(intn) { int Fn, Fn1, Fn2, ind; Fn2 = 0 ; Fn1 = 1 ; Fn = 0 ; if ( n == 1 ) Fn = 1 ; for (ind=2 ; ind <= n ; ind++){ Fn = Fn1 + Fn2; Fn2 = Fn1; Fn1 = Fn; } printf("F(%d) = %d n", n, Fn); }
  • 29.
    Fibonacci Recursive fibonacci(1) fibonacci(5) fibonacci(4) fibonacci(3) fibonacci(3)fibonacci(2) fibonacci(2) fibonacci(1) fibonacci(2) fibonacci(1) fibonacci(1) fibonacci(0) fibonacci(0) fibonacci(1) fibonacci(0) int fibonacci(int n) { if (n==0) return 0; if (n==1) return 1; return fibonacci(n-1) + fibonacci(n-2); }
  • 30.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5
  • 31.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5
  • 32.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5
  • 33.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5
  • 34.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… 2*… y 5
  • 35.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… y 4
  • 36.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… y 4
  • 37.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… y 4
  • 38.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4
  • 39.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… y 2
  • 40.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… y 2
  • 41.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… y 2
  • 42.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2
  • 43.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… y 1
  • 44.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… y 1
  • 45.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… y 1
  • 46.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… y 1
  • 47.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*… y 1
  • 48.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*… y 1 rec_pow(2, 0) x 2 Returns… y 0
  • 49.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*… y 1 rec_pow(2, 0) x 2 Returns… y 0
  • 50.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*… y 1 rec_pow(2, 0) x 2 Returns… 1 y 0
  • 51.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(…) y 2 rec_pow(2, 1) x 2 Returns… 2*1 y 1
  • 52.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(…) y 4 rec_pow(2, 2) x 2 Returns… square(2) y 2
  • 53.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… y 5 rec_pow(2, 4) x 2 Returns… square(4) y 4
  • 54.
    rec_pow – stepby step int rec_pow(int x, int y) { if (y == 0) return 1; if (y%2 == 0) return square(rec_pow(x,y/2)); else return x*rec_pow(x,y-1); } rec_pow(2, 5) x 2 Returns… 2*16 y 5
  • 55.
    Exercise Write a programthat receives two non-negative integers and computes their product recursively. Not * multiple operator !! Hint: Notice that the product a*b is actually a+a+… +a (b times).
  • 56.
    Solution int recMult( intx, int y ) { if( x == 0) return 0; return y + recMult( x-1,y); {
  • 57.
    Exercise Given the followingiterative version of sum-of-digits calculation Find the recursive definition of this function (don’t forget the base case!) int sum_digits(int n){ int sum = 0; while (n > 0) { sum += n%10; n = n/10; } return sum; }
  • 58.
    Solution int sumOfDigits( intx ) { if( x < 0) x *= -1; if( x == 0 ) return 0; else return x % 10 + sumOfDigits( x / 10 ); }
  • 59.
    More uses Recursion isa general approach to programming functions. Its uses are not confined to calculating mathematical expressions! For example : write a function that finds the max member in an array of integer.
  • 60.
    Solution int rec_max(int arr[], int size){ int rest; if (size == 1) return arr[0]; else { rest = rec_max(arr+1, size-1); if (arr[0] > rest) return arr[0]; else return rest; } }
  • 61.
    int BinarySearch(int arr[],intx, int left, int right) { int middle; if(left>right) return -1; else { middle=(left+right)/2); if(arr[middle]==x) return middle; else if(x < arr[middle]) return BinarySearch(arr,x,left,middle-1); else return BinarySearch(arr,x,middle+1,right); } }
  • 62.
    Towers of Hanoi TheTowers of Hanoi problem consists of three rods, and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks in a neat stack in ascending order of size on one rod, the smallest at the top, thus making a conical shape. The objective of the puzzle is to move the entire stack to another rod, obeying the following rules:  Only one disk may be moved at a time.  Each move consists of taking the upper disk from one of the rods and sliding it onto another rod, on top of the other disks that may already be present on that rod.  No disk may be placed on top of a smaller disk.
  • 63.
  • 64.
    Recursive Solution To moven disks from peg A to peg C:  move n−1 disks from A to B. This leaves disk #n alone on peg A  move disk #n from A to C  move n−1 disks from B to C so they sit on disk #n
  • 65.
    Recursive Solution -Function void hanoi(int x, char from, char to, char aux){ if(x==1){ printf("Move Disk From %c to %cn", from, to); } else { hanoi(x-1,from,aux,to); printf("Move Disk From %c to %cn", from, to); hanoi(x-1,aux,to,from); } }
  • 66.
    Scope of variables- reminder A variable declared within a function is unrelated to variables declared elsewhere. A function cannot access variables that are declared in other functions.