10 Examples for Recursion in JavaScript

Previous Page Next Page

1) Countdown from any number to 0

The program starts the countdown from n to 0 while printing a number every second. The recursive call “countDown(count-1)” is made inside callback function of the setTimeout() function. The base condition ensures that the countdown ends once the count is equal to 0.

function countDown(count){
  console.log(count);
  if(count==0){
    return;
  }
  setTimeout(()=>{countDown(count-1)},1000);
}

countDown(5);
// 5 4 3 2 1 0

2) Sum of digits of a number

The last digit of the num is added with a recursive call of “digitSum(num/10)” and the recursive call is terminated once the num variable is 0.

var number = 3467;

function digitSum(num){
  if(num==0){
    return num;
  }
  return num%10 + digitSum(Math.floor(num/10));
}

digitSum(number); // 20

3) Flattening of Array

In this example, the array with nested subarrays at n levels is flattened.

  1. if element at the index is an array, recursive call to flatten the subarray “flattenArray(arr[i],0)” is made.
  2. if the element is a number, there is no need to flatten hence element is directly pushed into the result array.
  3. After both cases, a recursive call to flatten the next element of the array “flattenArray(arr,i+1)” is made.
var arr = [2,[3,12,24],17,[54,[24,3],8]];
var result=[];

function flattenArray(arr,i){
  if(i>=arr.length){
    return;
  }
  if(Array.isArray(arr[i])){
    flattenArray(arr[i],0);
  }
  else{
    result.push(arr[i]);
  }
  flattenArray(arr,i+1);
}

flattenArray(arr,0);

console.log(result);
// [2, 3, 12, 24, 17, 54, 24, 3, 8]

4) Factorial of a number

The factorial of a number “factorial(i)” is broken down into “i*factorial(i-1)“. Every recursive call reaches the base condition where i <= 1 which returns 1.

function factorial(i) {
  if (i > 1) { 
    return factorial(i - 1) * i;
  }
  return 1;
}

console.log(factorial(5));
// 120

5) Fibonacci series

The Fibonacci number of n is calculated by adding the Fibonacci numbers of n-1 and n-2. Additionally, base conditions f(0) =0, f(1)=1 and f(2)=1 are included. 

function findFib(n){
  if(n<=0){
    return 0;
  }
  else if(n<3){
    return 1;
  }
 return findFib(n-1) + findFib(n-2);
}

console.log(findFib(5));
// 5

console.log(findFib(9));
// 34

6) Print elements of an array

The current array element “arr[i]” is printed and recursive call to print next element “printArray(arr, i + 1)” is made. Once all elements of the array are printed and “i” variable exceeds the array length, the function call is returned to avoid infinite recursion.

var arr = [2, 12, 34, 54, 41];

function printArray(arr, i) {
  if (i >= arr.length) {
    return;
  }
  console.log(`Element at index ${i} is ${arr[i]}`);
  printArray(arr, i + 1);
}
printArray(arr, 0);

// Element at index 0 is 2
// Element at index 1 is 12
// Element at index 2 is 34
// Element at index 3 is 54
// Element at index 4 is 41

7) Total sum of an array

The total sum of an array is calculated from the addition of the current array element arr[i] with a recursive call of the following index “arraySum(i+1,arr)“. The base condition “i >= arr.length” ensures termination beyond the last index of the array.

var arr = [2, 12, 34, 54, 41];

function arraySum(i,arr) {
  if (i >= arr.length) {
    return 0;
  }
  return arr[i] + arraySum(i+1,arr);
}

console.log(arraySum(0,arr));
// 143

8) Find an element using Binary Search

The recurse approach for binary search in a sorted array follows the steps:

  1. if low> high, the element is not found hence -1 is returned.
  2. else if search element x == arr[mid], the element is found, hence mid is returned.
  3. else if x > arr[mid], search element is expected to be present between mid+1 and high index.
  4. else search element is expected to be present between low and mid-1.
var arr=[2, 16, 23, 33, 41, 51, 73];
var x = 33;

function findElement(arr,x,low,high){
  var mid=low+high/2;
  if(low > high){
    return -1;
  }
  else{
    if(x==arr[mid]){
      return mid;
    }
    else if(x > arr[mid]){
      return findElement(arr,x,mid+1,high);
    }
    else{
      return findElement(arr,x,low,mid-1);
    }
  }
}

function searchElement(arr,x){
  const index = findElement(arr,x,0,arr.length-1);
  console.log(`${x} is found at index ${index}`);
}

searchElement(arr,x);
// 33 is found at index 3

9) Sum of nested objects

The “obj.value” is added with recursive call “findSum(obj.children)” and base condition “obj.children == null” ensures termination when no children object is present.

var myObject = {
    name: "object1",
    value: 3,
    children: {
      name: "object2",
      value: 5,
      children: null
    }
}

function findSum(obj){
  if(obj.children == null){
    return obj.value;
  }  
  return obj.value + findSum(obj.children);   
}

findSum(myObject);
// 8

10) Print all factors of a number

If the number is divided by a variable without any remainder then it will be printed. The recursive call “printFactors(number, fact+1)” ensures every factor between 1 to number/2 is printed.

function printFactors(number, fact){
  if(number/fact < 2){
    console.log(number)
    return;
  }  
  if(number%fact == 0){
    console.log(fact); 
  }
  return printFactors(number, fact+1);
}

function findFactors(number){
  printFactors(number,1);
}

findFactors(20);
// 1 
// 2
// 4
// 5
// 10
// 20

Related Articles