Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Backtracking to find all subsets

  • Difficulty Level : Medium
  • Last Updated : 10 Feb, 2022

Given a set of positive integers, find all its subsets. 
Examples: 
 

Input: array = {1, 2, 3}
Output: // this space denotes null element. 
         1
         1 2
         1 2 3
         1 3
         2
         2 3
         3
Explanation: These are all the subsets that 
can be formed using the array.

Input: 1 2
Output: 
         1 
         2
         1 2
Explanation: These are all the subsets that 
can be formed using the array.

 

The iterative solution is already discussed here: the iterative approach to find all subsets. This article aims to provide a backtracking approach.
Approach: The idea is simple, that if there are n number of elements inside an array, there are two choices for every element. Either include that element in the subset or do not include it. 
Using the above idea forms a recursive solution to the problem.
Algorithm: 
 

  1. Create a recursive function that takes the following parameters, input array, the current index, the output array, or current subset, if all the subsets need to be stored then a vector of the array is needed if the subsets need to be printed only then this space can be ignored.
  2. if the current index is equal to the size of the array, then print the subset or output array or insert the output array into the vector of arrays (or vectors) and return.
  3. There are exactly two choices for very index.
  4. Ignore the current element and call the recursive function with the current subset and next index, i.e i + 1.
  5. Insert the current element in the subset and call the recursive function with the current subset and next index, i.e i + 1.

Implementation: 
 

C++




// CPP program to find all subsets by backtracking.
#include <bits/stdc++.h>
using namespace std;
 
// In the array A at every step we have two
// choices for each element either  we can
// ignore the element or we can include the
// element in our subset
void subsetsUtil(vector<int>& A, vector<vector<int> >& res,
                 vector<int>& subset, int index)
{
    res.push_back(subset);
    for (int i = index; i < A.size(); i++) {
 
        // include the A[i] in subset.
        subset.push_back(A[i]);
 
        // move onto the next element.
        subsetsUtil(A, res, subset, i + 1);
 
        // exclude the A[i] from subset and triggers
        // backtracking.
        subset.pop_back();
    }
 
    return;
}
 
// below function returns the subsets of vector A.
vector<vector<int> > subsets(vector<int>& A)
{
    vector<int> subset;
    vector<vector<int> > res;
 
    // keeps track of current element in vector A;
    int index = 0;
    subsetsUtil(A, res, subset, index);
 
    return res;
}
 
// Driver Code.
int main()
{
    // find the subsets of below vector.
    vector<int> array = { 1, 2, 3 };
 
    // res will store all subsets.
    // O(2 ^ (number of elements inside array))
    // because at every step we have two choices
    // either include or ignore.
    vector<vector<int> > res = subsets(array);
 
    // Print result
    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



/*package whatever //do not write package name here */
 
import java.io.*;
import java.util.*;
class GFG {
    public static void
    findSubsets(List<List<Integer>> subset, ArrayList<Integer> nums, ArrayList<Integer> output, int index)
    {
      // Base Condition
        if (index == nums.size()) {
            subset.add(output);
            return;
        }
       
        // Not Including Value which is at Index
        findSubsets(subset, nums, new ArrayList<>(output), index + 1);
 
        // Including Value which is at Index
        output.add(nums.get(index));
        findSubsets(subset, nums, new ArrayList<>(output), index + 1);
    }
 
    public static void main(String[] args) {
       
      //Main List for storing all subsets
      List<List<Integer>> subset = new ArrayList<>();
       
      // Input ArrayList
      ArrayList<Integer> input = new ArrayList<>();
      input.add(1);
      input.add(2);
      input.add(3);
       
      findSubsets(subset, input, new ArrayList<>(), 0);
 
      // Comparator is used so that all subset get
      // sorted in ascending order of values
        Collections.sort(subset, (o1, o2) -> {
            int n = Math.min(o1.size(), o2.size());
            for (int i = 0; i < n; i++) {
                if (o1.get(i) == o2.get(i)){
                    continue;
                }else{
                    return o1.get(i) - o2.get(i);
                }
            }
            return 1;
        });
       
       
      // Printing Subset
      for(int i = 0; i < subset.size(); i++){
          for(int j = 0; j < subset.get(i).size(); j++){
              System.out.print(subset.get(i).get(j) + " ");
          }
          System.out.println();
      }
       
    }
}
Python3



# Python3 program to find all subsets
# by backtracking.
 
# In the array A at every step we have two
# choices for each element either we can
# ignore the element or we can include the
# element in our subset
def subsetsUtil(A, subset, index):
    print(*subset)
    for i in range(index, len(A)):
         
        # include the A[i] in subset.
        subset.append(A[i])
         
        # move onto the next element.
        subsetsUtil(A, subset, i + 1)
         
        # exclude the A[i] from subset and
        # triggers backtracking.
        subset.pop(-1)
    return
 
# below function returns the subsets of vector A.
def subsets(A):
    global res
    subset = []
     
    # keeps track of current element in vector A
    index = 0
    subsetsUtil(A, subset, index)
     
# Driver Code
 
# find the subsets of below vector.
array = [1, 2, 3]
 
# res will store all subsets.
# O(2 ^ (number of elements inside array))
# because at every step we have two choices
# either include or ignore.
subsets(array)
 
# This code is contributed by SHUBHAMSINGH8410
C#



/*package whatever //do not write package name here */
using System;
using System.Collections.Generic;
 
public class GFG {
  public static void
    findSubsets(List<List<int>> subset, List<int> nums, List<int> output, int index)
  {
    // Base Condition
    if (index == nums.Count) {
      subset.Add(output);
      return;
    }
 
    // Not Including Value which is at Index
    findSubsets(subset, nums, new List<int>(output), index + 1);
 
    // Including Value which is at Index
    output.Add(nums[index]);
    findSubsets(subset, nums, new List<int>(output), index + 1);
  }
 
  public static void Main(String[] args) {
 
    // Main List for storing all subsets
    List<List<int>> subset = new List<List<int>>();
 
    // Input List
    List<int> input = new List<int>();
    input.Add(1);
    input.Add(2);
    input.Add(3);
 
    findSubsets(subset, input, new List<int>(), 0);
 
    // Comparator is used so that all subset get
    // sorted in ascending order of values
    subset.Sort((o1, o2) => {
      int n = Math.Min(o1.Count, o2.Count);
      for (int i = 0; i < n; i++) {
        if (o1[i] == o2[i]){
          continue;
        }else{
          return o1[i] - o2[i];
        }
      }
      return 1;
    });
 
    // Printing Subset
    for(int i = 0; i < subset.Count; i++){
      for(int j = 0; j < subset[i].Count; j++){
        Console.Write(subset[i][j] + " ");
      }
      Console.WriteLine();
    }
 
  }
}
 
// This code is contributed by shikhasingrajput
Javascript



<script>
/*package whatever //do not write package name here */
function findSubsets(subset, nums, output, index)
{
 
    // Base Condition
    if (index == nums.length) {
        subset.push(output);
        return;
    }
 
    // Not Including Value which is at Index
    findSubsets(subset, nums, [...output], index + 1);
 
    // Including Value which is at Index
    output.push(nums[index]);
    findSubsets(subset, nums, [...output], index + 1);
}
 
// Main List for storing all subsets
let subset = [];
 
// Input ArrayList
let input = [];
input.push(1);
input.push(2);
input.push(3);
 
findSubsets(subset, input, [], 0);
 
// Comparator is used so that all subset get
// sorted in ascending order of values
subset.sort((o1, o2) => {
    let n = Math.min(o1.length, o2.length);
    for (let i = 0; i < n; i++) {
        if (o1[i] == o2[i]) {
            continue;
        } else {
            return o1[i] - o2[i];
        }
    }
    return 1;
});
 
// Printing Subset
for (let i = 0; i < subset.length; i++) {
    for (let j = 0; j < subset[i].length; j++) {
        document.write(subset[i][j] + " ");
    }
    document.write("<br>");
}
 
// This code is contributed by saurabh_jaiswal.
</script>
Output
1 
1 2 
1 2 3 
1 3 
2 
2 3 
3 
Complexity Analysis: 
 
  • Time Complexity: O(n(2 ^ n)). 
    For every index i two recursive cases originate, So Time Complexity is O(2^n). If we include the time taken to copy the subset vector into the res vector the time taken will be equal to the size of the subset vector.
  • Space Complexity: O(n). 
    The space complexity can be reduced if the output array is not stored and the static and global variable is used to store the output string.
 

My Personal Notes
arrow_drop_up
Previous
Find all distinct subsets of a given set using BitMasking Approach
Next

Finding all subsets of a given set in Java
Recommended Articles
Page :
Sum of subsets of all the subsets of an array | O(3^N)
30, Oct 19
Sum of subsets of all the subsets of an array | O(2^N)
31, Oct 19
Sum of subsets of all the subsets of an array | O(N)
31, Oct 19
Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once
04, Jan 21
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Divide array in two Subsets such that sum of square of sum of both subsets is maximum
07, Feb 20
Maximum number of subsets an array can be split into such that product of their minimums with size of subsets is at least K
21, Apr 21
Generate all distinct subsequences of array using backtracking
09, Oct 20
Print all possible permutations of an array with duplicates using Backtracking
15, Feb 21
Print all possible permutations of an Array/Vector without duplicates using Backtracking
26, Nov 21
The Knight's tour problem | Backtracking-1
14, Jul 11
Subset Sum | Backtracking-4
24, Sep 11
Hamiltonian Cycle | Backtracking-6
04, May 12
Solving Cryptarithmetic Puzzles | Backtracking-8
27, Mar 14
Word Break Problem using Backtracking
01, Jan 17
Top 20 Backtracking Algorithm Interview Questions
28, Apr 17
Magnet Puzzle | Backtracking-9
30, Oct 17
A backtracking approach to generate n bit Gray Codes
12, Dec 17
Backtracking | Introduction
23, Jul 18
Print the DFS traversal step-wise (Backtracking also)
17, Aug 18
Travelling Salesman Problem implementation using BackTracking
10, Apr 19
Maximal independent set from a given Graph using Backtracking
09, Jul 20
Difference between Backtracking and Branch-N-Bound technique
09, Jun 20
Maximum size subset with given sum using Backtracking
02, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
foreverrookie
@foreverrookie
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!