SlideShare a Scribd company logo

Recursion

Download as PPT, PDF
J
James Wong

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.

Technology
1 of 66
Downloaded 51 times
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
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
Ssankett Negi
 
PPT
Data Structures- Part5 recursion
Abdullah Al-hazmy
 
PPTX
Recursion
baabtra.com - No. 1 supplier of quality freshers
 
PDF
Iterations and Recursions
Abdul Rahman Sherzad
 
PPT
Recursion
Malainine Zaid
 
PPTX
Recursion
Abdur Rehman
 
PDF
Introduction to Recursion (Python)
Thai Pangsakulyanont
 
PPT
Ch10 Recursion
leminhvuong
 
Recursion
Ssankett Negi
 
Data Structures- Part5 recursion
Abdullah Al-hazmy
 
Recursion
baabtra.com - No. 1 supplier of quality freshers
 
Iterations and Recursions
Abdul Rahman Sherzad
 
Recursion
Malainine Zaid
 
Recursion
Abdur Rehman
 
Introduction to Recursion (Python)
Thai Pangsakulyanont
 
Ch10 Recursion
leminhvuong
 

What's hot (20)

PPS
Let Us Learn Lambda Using C# 3.0
Sheik Uduman Ali
 
PPTX
Recursion(Advanced data structure)
kurubameena1
 
PPTX
Lecture09 recursion
Hariz Mustafa
 
PDF
CPSC 125 Ch 2 Sec 4
David Wood
 
PPT
Primitive Recursive Functions
Radhakrishnan Chinnusamy
 
PPT
functions
Gaditek
 
PPTX
5.2 primitive recursive functions
Sampath Kumar S
 
PPTX
Asymptotic Notation
Protap Mondal
 
PDF
01. design & analysis of agorithm intro & complexity analysis
Onkar Nath Sharma
 
PPTX
Mathematical Analysis of Recursive Algorithm.
mohanrathod18
 
PPT
Induction
Lal Bdr. Saud
 
PPT
Algorithm.ppt
Tareq Hasan
 
PDF
Advanced C - Part 3
Emertxe Information Technologies Pvt Ltd
 
PPTX
Control System Homework Help
Matlab Assignment Experts
 
PDF
6-Python-Recursion.pdf
AshishPalandurkar2
 
PDF
Divide and Conquer
Mohammed Hussein
 
PDF
Algorithm chapter 2
chidabdu
 
PDF
Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala
Philip Schwarz
 
PPT
Arrays
archikabhatia
 
PPTX
Functions
PralhadKhanal1
 
Let Us Learn Lambda Using C# 3.0
Sheik Uduman Ali
 
Recursion(Advanced data structure)
kurubameena1
 
Lecture09 recursion
Hariz Mustafa
 
CPSC 125 Ch 2 Sec 4
David Wood
 
Primitive Recursive Functions
Radhakrishnan Chinnusamy
 
functions
Gaditek
 
5.2 primitive recursive functions
Sampath Kumar S
 
Asymptotic Notation
Protap Mondal
 
01. design & analysis of agorithm intro & complexity analysis
Onkar Nath Sharma
 
Mathematical Analysis of Recursive Algorithm.
mohanrathod18
 
Induction
Lal Bdr. Saud
 
Algorithm.ppt
Tareq Hasan
 
Advanced C - Part 3
Emertxe Information Technologies Pvt Ltd
 
Control System Homework Help
Matlab Assignment Experts
 
6-Python-Recursion.pdf
AshishPalandurkar2
 
Divide and Conquer
Mohammed Hussein
 
Algorithm chapter 2
chidabdu
 
Folding Unfolded - Polyglot FP for Fun and Profit - Haskell and Scala
Philip Schwarz
 
Arrays
archikabhatia
 
Functions
PralhadKhanal1
 
Ad

Similar to Recursion (20)

PDF
062636636366363773737373733+73737733+7.pdf
GauravKumar295392
 
PPTX
06 Recursion in C.pptx
MouDhara1
 
PDF
Recursion examples
HafsaZahran
 
PDF
Recursion.pdf
Flavia Tembo Kambale
 
PPTX
Recursion
Kasun Ranga Wijeweera
 
PPT
Lec-32 Recursion - Divide and Conquer in Queue
Anil Yadav
 
PPT
14 recursion
Himadri Sen Gupta
 
PPT
lecture 10 Recursive Function and Macros.ppt
Abhishekkumarsingh630054
 
PDF
Chapter VII RECURSION.pdf algor and data structure
benyakoubrania53
 
PPT
Basic_analysis.ppt
SoumyaJ3
 
PPT
chapter1.ppt
SankarTerli
 
PPT
chapter1.ppt
chetanvchaudhari
 
PPTX
Introduction to Dynamic Programming.pptx
PochupouOwo
 
PPT
Lec-6 Recursion of Data Structures & Algorithms
haseebanjum2611
 
DOCX
Recursion in C
Lakshmi Sarvani Videla
 
PDF
C and Data Structures Lab Solutions
Srinivas Reddy Amedapu
 
PDF
C lab excellent
Srinivas Reddy Amedapu
 
PDF
C and Data Structures
Srinivas Reddy Amedapu
 
PDF
DS & Algo 2 - Recursion
Mohammad Imam Hossain
 
PPT
Lecture9 recursion
Muhammad Zubair
 
062636636366363773737373733+73737733+7.pdf
GauravKumar295392
 
06 Recursion in C.pptx
MouDhara1
 
Recursion examples
HafsaZahran
 
Recursion.pdf
Flavia Tembo Kambale
 
Recursion
Kasun Ranga Wijeweera
 
Lec-32 Recursion - Divide and Conquer in Queue
Anil Yadav
 
14 recursion
Himadri Sen Gupta
 
lecture 10 Recursive Function and Macros.ppt
Abhishekkumarsingh630054
 
Chapter VII RECURSION.pdf algor and data structure
benyakoubrania53
 
Basic_analysis.ppt
SoumyaJ3
 
chapter1.ppt
SankarTerli
 
chapter1.ppt
chetanvchaudhari
 
Introduction to Dynamic Programming.pptx
PochupouOwo
 
Lec-6 Recursion of Data Structures & Algorithms
haseebanjum2611
 
Recursion in C
Lakshmi Sarvani Videla
 
C and Data Structures Lab Solutions
Srinivas Reddy Amedapu
 
C lab excellent
Srinivas Reddy Amedapu
 
C and Data Structures
Srinivas Reddy Amedapu
 
DS & Algo 2 - Recursion
Mohammad Imam Hossain
 
Lecture9 recursion
Muhammad Zubair
 
Ad

More from James Wong (20)

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

Recently uploaded (20)

PPTX
1. Introduction to Computer Programming.pptx
bonakiduza1024
 
PDF
Encapsulation_ Review paper, used for researhc scholars
gurumoop
 
PPTX
SOPHOS-XG Firewall Administrator PPT.pptx
AgnesMunisi
 
PDF
NewMind AI Weekly Chronicles - August'25-Week II
NewMind AI
 
PDF
Architecting across the Boundaries of two Complex Domains - Healthcare & Tech...
Peter Tan
 
PPTX
Programs and apps: productivity, graphics, security and other tools
4mqw9zch22
 
PDF
Heart disease approach using modified random forest and particle swarm optimi...
IAESIJAI
 
PDF
Encapsulation theory and applications.pdf
gurumoop
 
PPTX
KOM of Painting work and Equipment Insulation REV00 update 25-dec.pptx
muhammadmuneebnaeem7
 
PDF
Advanced methodologies resolving dimensionality complications for autism neur...
IAESIJAI
 
PPTX
Group 1 Presentation -Planning and Decision Making .pptx
MatthewLewis227954
 
PPT
Teaching material agriculture food technology
LiaRayya
 
PDF
Empathic Computing: Creating Shared Understanding
Mark Billinghurst
 
PDF
Accuracy of neural networks in brain wave diagnosis of schizophrenia
IAESIJAI
 
PDF
Machine learning based COVID-19 study performance prediction
IAESIJAI
 
PDF
gpt5_lecture_notes_comprehensive_20250812015547.pdf
Chinchu40
 
PPTX
cloud_computing_Infrastucture_as_cloud_p
mainakbhattacharya20
 
PDF
Approach and Philosophy of On baking technology
30anthuong17
 
PDF
TokAI - TikTok AI Agent : The First AI Application That Analyzes 10,000+ Vira...
SOFTTECHHUB
 
PDF
7 ChatGPT Prompts to Help You Define Your Ideal Customer Profile.pdf
SOFTTECHHUB
 
1. Introduction to Computer Programming.pptx
bonakiduza1024
 
Encapsulation_ Review paper, used for researhc scholars
gurumoop
 
SOPHOS-XG Firewall Administrator PPT.pptx
AgnesMunisi
 
NewMind AI Weekly Chronicles - August'25-Week II
NewMind AI
 
Architecting across the Boundaries of two Complex Domains - Healthcare & Tech...
Peter Tan
 
Programs and apps: productivity, graphics, security and other tools
4mqw9zch22
 
Heart disease approach using modified random forest and particle swarm optimi...
IAESIJAI
 
Encapsulation theory and applications.pdf
gurumoop
 
KOM of Painting work and Equipment Insulation REV00 update 25-dec.pptx
muhammadmuneebnaeem7
 
Advanced methodologies resolving dimensionality complications for autism neur...
IAESIJAI
 
Group 1 Presentation -Planning and Decision Making .pptx
MatthewLewis227954
 
Teaching material agriculture food technology
LiaRayya
 
Empathic Computing: Creating Shared Understanding
Mark Billinghurst
 
Accuracy of neural networks in brain wave diagnosis of schizophrenia
IAESIJAI
 
Machine learning based COVID-19 study performance prediction
IAESIJAI
 
gpt5_lecture_notes_comprehensive_20250812015547.pdf
Chinchu40
 
cloud_computing_Infrastucture_as_cloud_p
mainakbhattacharya20
 
Approach and Philosophy of On baking technology
30anthuong17
 
TokAI - TikTok AI Agent : The First AI Application That Analyzes 10,000+ Vira...
SOFTTECHHUB
 
7 ChatGPT Prompts to Help You Define Your Ideal Customer Profile.pdf
SOFTTECHHUB
 

Recursion

  • 2. 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; }
  • 3. 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.
  • 4. Recursive calling Example: void func(int n){ 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 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; }
  • 7. Conclusions for Recursive calling 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(int n){ 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(int n){ 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(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
  • 25. 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
  • 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(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); }
  • 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 – 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
  • 31. 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
  • 32. 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
  • 33. 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
  • 34. 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
  • 35. 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
  • 36. 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
  • 37. 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
  • 38. 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
  • 39. 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
  • 40. 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
  • 41. 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
  • 42. 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
  • 43. 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
  • 44. 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
  • 45. 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
  • 46. 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
  • 47. 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
  • 48. 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
  • 49. 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
  • 50. 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
  • 51. 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
  • 52. 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
  • 53. 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
  • 54. 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
  • 55. 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).
  • 56. Solution int recMult( int x, int y ) { if( x == 0) return 0; return y + recMult( x-1,y); {
  • 57. 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; }
  • 58. Solution int sumOfDigits( int x ) { if( x < 0) x *= -1; if( x == 0 ) return 0; else return x % 10 + sumOfDigits( x / 10 ); }
  • 59. 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.
  • 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[],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); } }
  • 62. 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.
  • 64. 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
  • 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.