Generating all possible Subsequences using Recursion including the empty one.

Last Updated : 26 Nov, 2024

Given an array arr[]. The task is to find all the possible subsequences of the given array using recursion.

Examples:

Input: arr[] = [1, 2, 3]
Output : [3], [2], [2, 3], [1], [1, 3], [1, 2], [1, 2, 3], []

Input: arr[] = [1, 2]
Output : [2], [1], [1, 2], []

Approach:

For every element in the array, there are two choices, either to include it in the subsequence or not include it. Apply this for every element in the array starting from index 0 until we reach the last index. Print the subsequence once the last index is reached.

The below diagram shows the recursion tree for array, arr[] = [1, 2].

C++

// C++ code to find all possible
// subsequences for given array using
// recursion

#include <bits/stdc++.h>
using namespace std;

void findSubsequences(int curr, vector<int> &arr, 
                      vector<int> &subarr, vector<vector<int>> &res) {
   
   // Base case: When we reach the end of the array,
    // add the current subsequence to the result
    if (curr == arr.size()) {
        res.push_back(subarr);
        return;
    }

    //  Include the current element in the subsequence
    subarr.push_back(arr[curr]);

    // Recurse to the next element
    findSubsequences(curr + 1, arr, subarr, res);  

    // Backtrack: Remove the current element and explore
   // the next possibility
    subarr.pop_back();

    //  Do not include the current element
  	// in the subsequence
    findSubsequences(curr + 1, arr, subarr, res);
}

int main() {
    vector<int> arr = {1, 2, 3};
    int n = arr.size();

    vector<int> subarr;
    vector<vector<int>> res;

    findSubsequences(0, arr, subarr, res);

    for (int i = 0; i < res.size(); i++) {
        for (int j = 0; j < res[i].size(); j++) {
            cout << res[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

Java

// Java code to find all possible
// subsequences for given array using
// recursion

import java.util.*;

class GfG {

    static void findSubsequences(int curr, int[] arr,
                                 List<Integer> subarr,
                                 List<List<Integer> > res) {
      
        // Base case: When we reach the end of the array,
        // add the current subsequence to the result
        if (curr == arr.length) {
            res.add(new ArrayList<>(
                subarr));  
                          
            return;
        }

        // Include the current element in
        // the subsequence
        subarr.add(arr[curr]);

        // Recurse to the next element
        findSubsequences(
            curr + 1, arr, subarr,
            res);  

        // Backtrack: Remove the current element and explore
        // the next possibility
        subarr.remove(subarr.size() - 1);

        //  Do not include the current
        // element in the subsequence
        findSubsequences(
            curr + 1, arr, subarr,
            res);  
                  
    }

    public static void main(String[] args) {
       
        int[] arr = { 1, 2, 3 };

        List<Integer> subarr = new ArrayList<>();

        List<List<Integer> > res = new ArrayList<>();

        findSubsequences(0, arr, subarr, res);

        
        for (List<Integer> subsequence : res) {
            for (int num : subsequence) {
                System.out.print(num + " ");
            }
            System.out.println(); 
                                  
        }
    }
}

Python

# Python program to find all possible
# subsequences for given array using
# recursion


def findSubsequences(curr, arr, subArr, res):
  
    # Base case: When we reach the end of the array,
    # add the current subsequence to the result
    if curr == len(arr):
        res.append(subArr.copy())
        return

    #  Include the current element in the subsequence
    subArr.append(arr[curr])

    # Recurse to the next element
    findSubsequences(curr + 1, arr, subArr, res)

    # Backtrack: Remove the current element and
    # explore the next possibility
    subArr.pop()

    #  Do not include the current element in the subsequence
    findSubsequences(curr + 1, arr, subArr, res)


if __name__ == "__main__":
    arr = [1, 2, 3]

    # Temporary list to store the 
    # current subsequence
    subArr = []

    # Resultant list to store all subsequences
    res = []

    # Call the function to find all subsequences
    # starting from index 0
    findSubsequences(0, arr, subArr, res)

    for subsequence in res:
        print(" ".join(map(str, subsequence)))

// C# code to find all possible
// subsequences for given array using
// recursion

using System;
using System.Collections.Generic;

class GfG {

    static void findSubsequences(int curr, int[] arr,
                                 List<int> subArr,
                                 List<List<int> > res) {

        // Base case: When we reach the end of the array,
        // add the current subsequence to the result
        if (curr == arr.Length) {
            res.Add(new List<int>(subArr));
            return;
        }

        // Include the current element in
        // the subsequence
        subArr.Add(arr[curr]);

        // Recurse to the next element
        findSubsequences(curr + 1, arr, subArr, res);

        // Backtrack: Remove the current element and explore
        // the next possibility
        subArr.RemoveAt(subArr.Count - 1);

        //  Do not include the current
        // element in the subsequence
        findSubsequences(curr + 1, arr, subArr, res);
    }

    static void Main() {
        int[] arr = { 1, 2, 3 };

        // Temporary list to store the current subsequence
        List<int> subArr = new List<int>();

        // Resultant list to store all subsequences
        List<List<int> > res = new List<List<int> >();

        // Call the function to find all subsequences
        // starting from index 0
        findSubsequences(0, arr, subArr, res);

        foreach(var subsequence in res) {
            Console.WriteLine(
                string.Join(" ", subsequence));
        }
    }
}

JavaScript

// JavaScript code to find all possible
// subsequences for given array using
// recursion

function findSubsequences(curr, arr, subArr, res) {

    // Base case: When we reach the end of the array, add
    // the current subsequence to the result
    if (curr === arr.length) {
        res.push([...subArr ]);
        return;
    }

    // Include the current element in the
    // subsequence
    subArr.push(arr[curr]);

    // Recurse to the next element
    findSubsequences(curr + 1, arr, subArr, res);

    // Backtrack: Remove the current element and explore the
    // next possibility
    subArr.pop();

    //  Do not include the current element in
    // the subsequence
    findSubsequences(curr + 1, arr, subArr, res);
}

const arr = [ 1, 2, 3 ];

let subArr = [];
let res = [];

findSubsequences(0, arr, subArr, res);

res.forEach(subsequence => {
    console.log(subsequence.join(
        " "));
});

Output

Time complexity: O(2^n)
Auxiliary Space: O(n)

Related article:

Reverse a linked list using recursion

rituraj_jain

Improve

Article Tags :

Practice Tags :

Generating all possible Subsequences using Recursion including the empty one.

Similar Reads

Thank You!

What kind of Experience do you want to share?