10. Recursion

Recursion
Recursive Algorithms
and Backtracking
SoftUni Team
Technical Trainers
Software University
http://softuni.bg

2
1. What is Recursion?
2. Recursive Factorial
3. Generating 0/1 Vectors and Combinations
4. Backtracking
 The 8 Queens Problem
 Finding All Paths in a Labyrinth Recursively
5. Recursion or Iteration?
 Harmful Recursion and Optimizing Bad Recursion
Table of Contents

3
 The stack is a small fixed-size chunk of memory (e.g. 1MB)
 Keeps the currently called functions in a stack data structure
 Changes as the program enters / exits a function
The Stack
static void Main()
{
Print("Hello");
}
Main()
Print()
When Print is called it is
pushed onto the stack
When Print returns it
gets popped from the stack
Stack

Debugging a Program
Call Stack Live Demo

6
 Recursion is when a method calls itself
 Powerful technique for combinatorial
and branched search algorithms design
 Recursion should have:
 Direct or indirect recursive call
 The method calls itself directly
 Оr through other methods
 Exit criteria (bottom)
 Prevents infinite recursion
What is Recursion?

7
 Recursive definition of n! (n factorial):
Recursive Factorial – Example
n! = n * (n–1)! for n > 0
0! = 1
 5! = 5 * 4! = 5 * 4 * 3 * 2 * 1 * 1 = 120
 4! = 4 * 3! = 4 * 3 * 2 * 1 * 1 = 24
 3! = 3 * 2! = 3 * 2 * 1 * 1 = 6
 2! = 2 * 1! = 2 * 1 * 1 = 2
 1! = 1 * 0! = 1 * 1 = 1
 0! = 1

8
 Calculating factorial:
 0! = 1
 n! = n* (n-1)!, n>0
Recursive Factorial – Example
static decimal Factorial(int num)
{
if (num == 0)
return 1;
else
return num * Factorial(num - 1);
}
The bottom of
the recursion
Recursive call: the
method calls itself

Recursive Array Sum
In-Class Exercise (Lab)
10 3 7 3 4 27

11
 Recursive calls are slightly slower than iteration
 Parameters and return values travel through the stack at each step
 Prefer iteration for linear calculations (without branched calls)
Performance: Recursion vs. Iteration
static long RecurFact(int n)
{
if (n == 0)
return 1;
else
return n * Fact(n - 1);
}
static long IterFact(int num)
{
long result = 1;
for (int i = 1; i <= n; i++)
result *= i;
return result;
}
Recursive factorial: Iterative factorial:

Factorial Performance
Live Demo

13
 Infinite recursion == a method calls itself infinitely
 Typically, infinite recursion == bug in the program
 The bottom of the recursion is missing or wrong
 In C# / Java / C++ causes "stack overflow" error
Infinite Recursion
static long Calulate(int n)
{
return Calulate(n + 1);
}

15
 Direct recursion
 A method directly calls itself
 Indirect recursion
 Method A calls B, method B calls A
 Or even A  B  C  A
 Funny example of infinite indirect recursion:
 http://www.nakov.com/blog/2013/01/23/indirect-recursion/
Direct and Indirect Recursion
void A() {
…
A();
}
void A() {
…
B();
}
void B() {
…
A();
}

16
 Recursive methods have 3 parts:
 Pre-actions (before calling the recursion)
 Recursive calls (step-in)
 Post-actions (after returning from recursion)
 Recursive computation can be based on:
 Pre-actions + recursive calls (forward way)
 Recursive calls + post-actions (backward way)
 Pre-actions + recursive calls + post-actions (combined way)
Recursion Pre-Actions and Post-Actions

17
Pre-Actions and Post-Actions – Example
static void PrintFigure(int n)
{
if (n == 0) // Bottom of the recursion
return;
// Pre-action: print n asterisks
Console.WriteLine(new string('*', n));
// Recursive call: print figure of size n-1
PrintFigure(n - 1);
// Post-action: print n hashtags
Console.WriteLine(new string('#', n));
}

Pre-Actions
and Post-Actions
Live Demo

19
 How to generate all 8-bit vectors recursively?
 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 1
 ...
 0 1 1 1 1 1 1 1
 1 0 0 0 0 0 0 0
 ...
 1 1 1 1 1 1 1 0
 1 1 1 1 1 1 1 1
 How to generate all n-bit vectors?
Generating 0/1 Vectors

20
 Algorithm Gen01(n): put 0 and 1 at the last position n and call
Gen01(n-1) for the rest:
Generating 0/1 Vectors (2)
x x x x x x 0
Gen01(6):
Gen01(5)
x x x x x x 1
Gen01(5)
x x x x x 0 y
Gen01(5):
Gen01(4)
x x x x x 1 y
Gen01(4)
…
Gen01(-1):
Print;
Stop!


21
Generating 0/1 Vectors (3)
static void Gen01(int index, int[] vector)
{
if (index < 0)
Print(vector);
else
for (int i = 0; i <= 1; i++)
{
vector[index] = i;
Gen01(index-1, vector);
}
}
static void Main()
{
int n = 8;
int[] vector = new int[n];
Gen01(n-1, vector);
}

Generating 0/1 Vectors
Live Demo

Generating Combinations
Simple Recursive Algorithm

24
 Combinations in math represent all the ways to extract a subset
from a larger set of elements
 Select k members from a set of n elements
 Example: we can select 3 different elements from the set
{4, 5, 6, 7, 8} in 10 different ways:
(4, 5, 6) (4, 5, 7) (4, 5, 8) (4, 6, 7) (4, 6, 8)
(4, 7, 8) (5, 6, 7) (5, 6, 8) (5, 7, 8) (6, 7, 8)
 Combinations with and without repetitions can be easily
generated with recursion

25
 Algorithm GenCombs(k): put the numbers [1 … n] at position k
and call GenCombs(k+1) recursively for the rest of the elements:
Generating Combinations (2)
1 x x x x x x
GenCombs(0):
GenCombs(1)
Put all numbers in range
[1..n] at position k
1 1 x x x x x
GenCombs(1):
GenCombs(2)
Put all numbers in range
[1..n] at position k
GenCombs(n):
…
Print;
Stop!
Bottom of
recursion

26
Generating Combinations (3)
static void GenCombs(
int[] arr, int index, int startNum, int endNum)
{
if (index >= arr.Length) // Combination found --> print it
Console.WriteLine("(" + String.Join(", ", arr) + ")");
else
for (int i = startNum; i <= endNum; i++)
{
arr[index] = i;
GenCombs(arr, index + 1,
i + 1, endNum);
}
}
static void Main()
{
int[] arr = new int[3];
GenCombs(arr, 0, 4, 8);
}

Live Demo

Backtracking
Solving Computational Problems
by Generating All Candidates

29
 What is backtracking?
 Backtracking is a class of algorithms for finding all solutions to
some combinatorial computational problem
 E.g. find all paths from Sofia to Varna
 How does backtracking work?
 At each step tries all perspective possibilities recursively
 Drop all non-perspective possibilities as early as possible
 Backtracking has exponential running time!
Backtracking

30
Backtracking Algorithm (Pseudocode)
void Backtracking(Node node)
{
if (node is solution)
PrintSolution(node);
else
for each child c of node
if (c is perspective candidate)
{
MarkPositionVisited(c);
Backtracking(c);
UnmarkPositionVisited(c);
}
}

The "8 Queens" Puzzle
Backtracking in Practice

32
 Write a program to find all
possible placements of
 8 queens on a chessboard
 So that no two queens can
attack each other
 http://en.wikipedia.org/wiki/
Eight_queens_puzzle

33
 Backtracking
algorithm
 For finding all
solutions to the
"8 Queens Puzzle"
 At each step:
 Put a queen at
free position
 Recursive call
 Remove the
queen
Solving The "8 Queens" Puzzle
void PutQueens(row)
{
if (row == 8)
PrintSolution();
else
for (col = 0 … 7)
if (CanPlaceQueen(row, col))
{
MarkAllAttackedPositions(row, col);
PutQueens(row + 1);
UnmarkAllAttackedPositions(row, col);
}
}

In-Class Exercise (Lab)

35
 We are given a labyrinth
 Represented as matrix of cells of size M x N
 Empty cells are passable, the others (*) are not
 We start from the top left corner and can move in all 4 directions:
left, right, up, down
 We want to find all paths to the bottom right corner
Finding All Paths in a Labyrinth
Start
position
End
position

36
 There are 3 different paths from the top left corner to the
bottom right corner:
Finding All Paths in a Labyrinth (2)
0 1 2 *
* * 3 * *
6 5 4
7 * * * * *
8 9 10 11 12 13 14
0 1 2 * 8 9 10
* * 3 * 7 * 11
4 5 6 12
* * * * * 13
14
1) 2)
0 1 2 *
* * 3 * *
4 5 6 7 8
* * * * * 9
10
3)

37
 Suppose we have an algorithm FindExit(x,y) that finds and prints
all paths to the exit (bottom right corner) starting from position (x,y)
 If (x,y) is not passable, no paths are found
 If (x,y) is already visited, no paths are found
 Otherwise:
 Mark position (x,y) as visited (to avoid cycles)
 Find recursively all paths to the exit from all neighbor cells: (x-1,y) ,
(x+1,y) , (x,y+1) , (x,y-1)
 Mark position (x,y) as free (can be visited again)
Finding All Paths in a Labyrinth (3)

38
 Representing the labyrinth as matrix of characters (in this example 5
rows and 7 columns):
 Spaces (' ') are passable cells
 Asterisks ('*') are not passable
 The symbol 'e' is the exit (can occur multiple times)
Find All Paths: Algorithm
static char[,] lab =
{
{' ', ' ', ' ', '*', ' ', ' ', ' '},
{'*', '*', ' ', '*', ' ', '*', ' '},
{' ', ' ', ' ', ' ', ' ', ' ', ' '},
{' ', '*', '*', '*', '*', '*', ' '},
{' ', ' ', ' ', ' ', ' ', ' ', 'е'},
};

39
Find All Paths: Algorithm (2)
static void FindExit(int row, int col)
{
if ((col < 0) || (row < 0) || (col >= lab.GetLength(1))
|| (row >= lab.GetLength(0)))
{
// We are out of the labyrinth -> can't find a path
return;
}
// Check if we have found the exit
if (lab[row, col] == 'е')
{
Console.WriteLine("Found the exit!");
}
if (lab[row, col] != ' ')
{
// The current cell is not free -> can't find a path
return;
}
(example continues)

40
Find All Paths: Algorithm (3)
// Temporaryly mark the current cell as visited
lab[row, col] = 's';
// Invoke recursion to explore all possible directions
FindExit(row, col - 1); // left
FindExit(row - 1, col); // up
FindExit(row, col + 1); // right
FindExit(row + 1, col); // down
// Mark back the current cell as free
lab[row, col] = ' ';
}
static void Main()
{
FindExit(0, 0);
}

Find All Paths in a Labyrinth
Live Demo

42
 How to print all paths found by our recursive algorithm?
 Each move's direction can be stored in a list
 Need to pass the movement direction at each recursive call (L, R,
U, or D)
 At the start of each recursive call the current direction is
appended to the list
 At the end of each recursive call the last direction is removed from
the list
Find All Paths and Print Them
static List<char> path = new List<char>();

43
Find All Paths and Print Them (2)
static void FindPathToExit(int row, int col, char direction)
{
...
// Append the current direction to the path
path.Add(direction);
if (lab[row, col] == 'е')
{
// The exit is found -> print the current path
}
...
// Recursively explore all possible directions
FindPathToExit(row, col - 1, 'L'); // left
FindPathToExit(row - 1, col, 'U'); // up
FindPathToExit(row, col + 1, 'R'); // right
FindPathToExit(row + 1, col, 'D'); // down
...
// Remove the last direction from the path
path.RemoveAt(path.Count - 1);
}

Find and Print All Paths
in a Labyrinth
Live Demo

Recursion or Iteration?
When to Use and When to Avoid Recursion?

46
 When used incorrectly recursion could take too much memory and
computing power
 Example:
Recursion Can be Harmful!
static decimal Fibonacci(int n)
{
if ((n == 1) || (n == 2))
return 1;
else
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
static void Main()
{
Console.WriteLine(Fibonacci(10)); // 89
Console.WriteLine(Fibonacci(50)); // This will hang!
}

48
 fib(n) makes about fib(n) recursive calls
 The same value is calculated many, many times!
How the Recursive Fibonacci Calculation Works?

49
 Each Fibonacci
sequence member
 Can be remembered
once it is calculated
 Can be returned
directly when needed
again
Fast Recursive Fibonacci
static decimal[] fib = new decimal[MAX_FIB];
static decimal Fib(int n)
{
if (fib[n] == 0)
{
// fib[n] is still not calculated
if ((n == 1) || (n == 2))
fib[n] = 1;
else
fib[n] = Fib(n - 1) + Fib(n - 2);
}
return fib[n];
}

Fast Recursive Fibonacci
Live Demo

51
 Avoid recursion when an obvious iterative algorithm exists
 Examples: factorial, Fibonacci numbers
 Use recursion for combinatorial algorithms where
 At each step you need to recursively explore more than one
possible continuation
 I.e. for branched recursive algorithms
 Examples: permutations, all paths in a labyrinth
 If you have only one recursive call in the body of a recursive
method, it can directly become iterative (like calculating factorial)
When to Use Recursion?

52
 Recursion means to call a method from itself
 It should always have a bottom at which the recursive calls stop
 Very powerful technique for implementing combinatorial algorithms
 Examples: generating combinatorial configurations like vectors,
permutations, combinations, variations, etc.
 Backtracking finds all solutions / optimal solution of
combinatorial problem by generating all possibilities
 Without non-perspective candidates
 Recursion can be harmful when not used correctly
Summary

?
Recursion
https://softuni.bg/trainings/1331/algorithms-april-2016

License
 This course (slides, examples, labs, videos, homework, etc.)
is licensed under the "Creative Commons Attribution-
NonCommercial-ShareAlike 4.0 International" license
54
 Attribution: this work may contain portions from
 "Fundamentals of Computer Programming with C#" book by Svetlin Nakov & Co. under CC-BY-SA license
 "Data Structures and Algorithms" course by Telerik Academy under CC-BY-NC-SA license

Free Trainings @ Software University
 Software University Foundation – softuni.org
 Software University – High-Quality Education,
Profession and Job for Software Developers
 softuni.bg
 Software University @ Facebook
 facebook.com/SoftwareUniversity
 Software University @ YouTube
 youtube.com/SoftwareUniversity
 Software University Forums – forum.softuni.bg

10. Recursion

More Related Content

What's hot (20)

Similar to 10. Recursion (20)

More from Intro C# Book (20)

Recently uploaded (20)

10. Recursion

Editor's Notes