Generating all possible Subsequences using Recursion including the empty one.

25 May, 2022
Given an array. The task is to generate and print all of the possible subsequences of the given array using recursion.
Examples: 
Input : [1, 2, 3]
Output : [3], [2], [2, 3], [1], [1, 3], [1, 2], [1, 2, 3], []

Input : [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. 
Below diagram shows the recursion tree for array, arr[] = {1, 2}.  
Below is the implementation of the above approach. 
C++
Java
Python3
C#
Javascript
// C++ code to print all possible// subsequences for given array using// recursion#include <bits/stdc++.h>using namespace std;   // Recursive function to print all// possible subsequences for given arrayvoid printSubsequences(int arr[], int index,                       vector<int> &subarr,int n){    // Print the subsequence when reach    // the leaf of recursion tree    if (index == n)    {         for (auto it:subarr){           cout << it << " ";                   }      if(subarr.size()==0)        cout<<"{}";             cout<<endl;      return;              }    else    {       //pick the current index into the subsequence.        subarr.push_back(arr[index]);                 printSubsequences(arr, index + 1, subarr,n);                  subarr.pop_back();             //not picking the element into the subsequence.        printSubsequences(arr, index + 1, subarr,n);    }    } // Driver Codeint main(){    int arr[]={1, 2, 3};    int n=sizeof(arr)/sizeof(arr[0]);    vector<int> vec;           printSubsequences(arr, 0, vec,n);     return 0;} // This code is contributed by// vivekr4400
// Java code to print all possible// subsequences for given array using// recursionimport java.io.*;import java.util.*; class GFG{       // Recursive function to print all// possible subsequences for given arraypublic static void printSubsequences(int[] arr, int index,                                     ArrayList<Integer> path){         // Print the subsequence when reach    // the leaf of recursion tree    if (index == arr.length)    {                 // Condition to avoid printing        // empty subsequence        if (path.size() > 0)            System.out.println(path);    }         else    {                 // Subsequence without including        // the element at current index        printSubsequences(arr, index + 1, path);                 path.add(arr[index]);                 // Subsequence including the element        // at current index        printSubsequences(arr, index + 1, path);                 // Backtrack to remove the recently        // inserted element        path.remove(path.size() - 1);    }    return;} // Driver codepublic static void main(String[] args){    int[] arr = { 1, 2, 3 };             // Auxiliary space to store each path      ArrayList<Integer> path = new ArrayList<>();             printSubsequences(arr, 0, path);}} // This code is contributed by Mukul Sharma
# Python3 code to print all possible # subsequences for given array using # recursion   # Recursive function to print all# possible subsequences for given arraydef printSubsequences(arr, index, subarr):           # Print the subsequence when reach     # the leaf of recursion tree    if index == len(arr):                   # Condition to avoid printing        # empty subsequence        if len(subarr) != 0:            print(subarr)           else:        # Subsequence without including         # the element at current index        printSubsequences(arr, index + 1, subarr)                   # Subsequence including the element        # at current index        printSubsequences(arr, index + 1,                             subarr+[arr[index]])           return           arr = [1, 2, 3]   printSubsequences(arr, 0, []) #This code is contributed by Mayank Tyagi
// C# code to print all possible// subsequences for given array using// recursionusing System;using System.Collections.Generic;class GFG {         // Recursive function to print all    // possible subsequences for given array    static void printSubsequences(int[] arr, int index, List<int> path)    {                  // Print the subsequence when reach        // the leaf of recursion tree        if (index == arr.Length)        {                          // Condition to avoid printing            // empty subsequence            if (path.Count > 0)            {                Console.Write("[");                for(int i = 0; i < path.Count - 1; i++)                {                    Console.Write(path[i] + ", ");                }                Console.WriteLine(path[path.Count - 1] + "]");            }        }                  else        {                          // Subsequence without including            // the element at current index            printSubsequences(arr, index + 1, path);                          path.Add(arr[index]);                          // Subsequence including the element            // at current index            printSubsequences(arr, index + 1, path);                          // Backtrack to remove the recently            // inserted element            path.RemoveAt(path.Count - 1);        }        return;    }   static void Main() {      int[] arr = { 1, 2, 3 };              // Auxiliary space to store each path      List<int> path = new List<int>();              printSubsequences(arr, 0, path);  }} // This code is contributed by rameshtravel07.
<script>// Javascript code to print all possible// subsequences for given array using// recursion // Recursive function to print all// possible subsequences for given arrayfunction printSubsequences(arr, index, path){   // Print the subsequence when reach  // the leaf of recursion tree  if (index == arr.length)  {       // Condition to avoid printing    // empty subsequence    if (path.length > 0) document.write(`[${path}]<br>`);  }  else  {       // Subsequence without including    // the element at current index    printSubsequences(arr, index + 1, path);     path.push(arr[index]);     // Subsequence including the element    // at current index    printSubsequences(arr, index + 1, path);     // Backtrack to remove the recently    // inserted element    path.pop();  }  return;} // Driver codelet arr = [1, 2, 3]; // Auxiliary space to store each pathlet path = new Array(); printSubsequences(arr, 0, path); // This code is contributed by gfgking</script>
output
1 2 3  
1 2  
1 3  
1  
2 3  
2  
3  
{}
Time Complexity: 
Space Complexity: O(n) , Because of the recursion stack.  
sanjeev2552
mayanktyagi1709
msharma04
gfgking
adnanirshad158
rameshtravel07
vivekr4400
tausifsiddiqui
C-String-Question
subsequence
Technical Scripter 2018
Python
Recursion
Technical Scripter
Recursion
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Python Dictionary
Different ways to create Pandas Dataframe
Enumerate() in Python
Read a file line by line in Python
Python String | replace()
Write a program to print all permutations of a given string
Recursion
Program for Tower of Hanoi
Backtracking | Introduction
Recursive Practice Problems with Solutions