Display All Subsets of An Integer Array in Java

An integer array (or array list) is given to us. Our task is to print all the subsets of the given integer array (excluding empty subsets). Note that the order in which subsets are displayed does not matter.

Example 1:

Input

int inputArr[] = {1, 2, 3}

Output: {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}

Example 2:

Input

int inputArr[] = {1, 2, 3, 4, 5}

Output: {1}, {2}, {3}, {4}, {5}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, {2, 4}, {2, 5}, {3, 4}, {3, 5}, {4, 5}, {1, 2, 3}, {1, 2, 4}, {1, 2, 5}, {1, 3, 4}, {1, 3, 5}, (1, 4, 5}, {2, 3, 4}, {2, 3, 5}, {2, 4, 5}, {3, 4, 5}, {1, 2, 3, 4}, {1, 2, 3, 5}, {1, 2, 4, 5}, {1, 3, 4, 5}, {2, 3, 4, 5}, {1, 2, 3, 4, 5}

Approach: Using Backtracking

With the help of backtracking, we can generate all of the subsets of the given array. For every element, we have only two options. One is to include that element in the current subset. The other is to exclude that element from the current subset. In this way, we can generate all of the subsets of the given integer array.

The steps are as follows:

Step 1: Create a 2D array list answer for keeping all of the subsets.

Step 2: Also create a list tmp for keeping the current subset.

Step 3: Make a recursive method getSubset() that has the following four parameters:

Step 4: One is for keeping the current index. The second one is for storing the current subset. The third one is for storing all of the generated subsets (2D list), and the fourth one is the input array.

Step 5: Invoke the method with the current index as 0, empty current vector (initially, there will be no subset), the empty 2D list, and the input integer array.

Step 6: In the getSubset() method, we include the ith element in to the list tmp and recursively invoke getSubset() with value i + 1.

Step 7: When the method call is returned, we delete the ith element from the tmp list and then invoke getSubset() method again with i + 1.

Step 8: If the value of i is the same as the size of the input array, then add the list tmp to the list answer.

Step 9: Eventually, sort and display each of the subarrays that are there in the list answer.

Now let's see the implementation of the steps mentioned above.

FileName: SubsetIntArr.java

// important import statements
import java.util.Collections;
import java.util.ArrayList;

public class SubsetIntArr
{

// method that displays all the subsets with the help of the method getSubsets
public void displayAllSubsets(int s, ArrayList<Integer> inputArrList) 
{

// 2D list for keeping all the subset found answer
ArrayList<ArrayList<Integer>> answer = new ArrayList<>();

// a temporary list for keeping the current subset
ArrayList<Integer> tmp = new ArrayList<>();

// the first call to the recursive method
getSubsets(0, tmp, answer, inputArrList);

// Printing the final answer
for (int i = 0; i < answer.size(); i++) 
{
// Sorting and printing each subset
Collections.sort(answer.get(i));
System.out.print("[ ");
for (int j = 0; j < answer.get(i).size(); j++) 
{
System.out.print(answer.get(i).get(j) + " ");
}
System.out.print("]");
System.out.println( );
}

}

// a method that generates all the subsets of the input list
private void getSubsets(int i, ArrayList<Integer> tmp, ArrayList<ArrayList<Integer>> answer, ArrayList<Integer> inputArrList) 
{

// handling the base case
if (i == inputArrList.size()) 
{
// including the generated current subset (which is non empty) to the 2D list answer
if (tmp.size() > 0) 
{
answer.add(tmp);
}
return;
}

// Invoking the subset that has the ith array element inside it
ArrayList<Integer> tmp1 = new ArrayList<>(tmp);
tmp1.add(inputArrList.get(i));
getSubsets(i + 1, tmp1, answer, inputArrList);

// Generating the subset that will not contain the ith array element 
getSubsets(i + 1, tmp, answer, inputArrList);
}

// main method
public static void main(String argvs[]) 
{

// creating an object of the class SubsetIntArr
SubsetIntArr obj = new SubsetIntArr();

// creating an object of the class ArrayList
ArrayList<Integer> arrList = new ArrayList<Integer>(); 

// input 1
for (int j = 1; j <= 3; j++)
{
    arrList.add(j);
}

System.out.println("For the array list: " + arrList + " \n");

System.out.println("The subsets are: ");

obj.displayAllSubsets(arrList.size(), arrList );

System.out.println();

arrList.clear();

// input 2
for (int j = 1; j <= 5; j++)
{
    arrList.add(j);
}

System.out.println("For the array list: " + arrList + " \n");

System.out.println("The subsets are: ");

obj.displayAllSubsets(arrList.size(), arrList );



}
}

Output:

For the array list: [1, 2, 3] 

The subsets are: 
[ 1 2 3 ]
[ 1 2 ]
[ 1 3 ]
[ 1 ]
[ 2 3 ]
[ 2 ]
[ 3 ]

For the array list: [1, 2, 3, 4, 5] 

The subsets are: 
[ 1 2 3 4 5 ]
[ 1 2 3 4 ]
[ 1 2 3 5 ]
[ 1 2 3 ]
[ 1 2 4 5 ]
[ 1 2 4 ]
[ 1 2 5 ]
[ 1 2 ]
[ 1 3 4 5 ]
[ 1 3 4 ]
[ 1 3 5 ]
[ 1 3 ]
[ 1 4 5 ]
[ 1 4 ]
[ 1 5 ]
[ 1 ]
[ 2 3 4 5 ]
[ 2 3 4 ]
[ 2 3 5 ]
[ 2 3 ]
[ 2 4 5 ]
[ 2 4 ]
[ 2 5 ]
[ 2 ]
[ 3 4 5 ]
[ 3 4 ]
[ 3 5 ]
[ 3 ]
[ 4 5 ]
[ 4 ]
[ 5 ]

Complexity Analysis: It is evident that one recursive call leads to two more recursive calls. Considering this fact gives the time complexity (2N). Also, O(N) time requires printing each subset. Therefore, the total time complexity of the program is O(N x 2N). The 2-D array list stores all the subsets, and the total number of subsets is O(2N), and a subset can have the maximum O(N) size. Therefore, the space complexity of the program is O(N x 2N), where the total number of elements present in the input list is N.

Implementation: Using Bit Masking

One of the prominent techniques for finding all the subsets is to use bit masking. In this approach, we have to treat each element of the input list as its corresponding bit. If that bit is set, then we will include that element in the current subset; otherwise, not. Consider an array consisting of three elements.

Int arr[] = {4, 5, 9}. Since there are three elements, we will take three bits. For three bits there are 8 (23 = 8) different possibilities 000, 001, 010, 011, 100, 101, 110, 111. If we consider the possibilities from left to the right, then the first possibility (000) does not include any element. The second possibility, 001, only includes 3rd element (arr[2]). The third possibility, 010, includes the 2nd element (arr[1]). The fourth possibility, 011, includes the 2nd and 3rd elements (arr[1] and arr[2]). The fifth possibility, 100, includes the 1st element (arr[0]), and so on. Thus,

All 8 Possibilities	Corresponding elements (Subsets)
000	[]
001	[9]
010	[5]
011	[5, 9]
100	[4]
101	[4, 9]
110	[4, 5]
111	[4, 5, 9]

Since we are not considering any empty subset, the subsets we get are:

[9], [5], [5, 9], [4], [4, 9], [4, 5], [4, 5, 9] of the input array [4, 5, 9]. It is our required answer. Now let's see the steps involved.

Step 1: Declare a 2-D list answer for keeping all of the subsets.

Step 2: Start a for-loop for val from 1 to 2^N -1

Step 3: Also, start an inner for-loop from 0 to N - 1

Step 4: If the i^th bit in val is set to 1, then add the i^th element of the input array in the current subset.

Step 5: Add each generated subset into the 2-D list answer.

Step 6: Eventually, sort and display each list inside the 2-D list answer with the help of a new line.

Now let's see the implementation of the steps mentioned above.

FileName: SubsetIntArr1.java

// important import statements
import java.util.Collections;
import java.util.ArrayList;

public class SubsetIntArr1
{

// method that displays all the subsets with the help of the method getSubsets
public void displayAllSubsets(int s, ArrayList<Integer> inputArrList) 
{
// 2D vector for storing the final array list
ArrayList<ArrayList<Integer>> answer = new ArrayList<>();

// Temporary vector for keeping the current subset

// Iterate from 1 to 2 ^ N - 1
for (int val = 1; val <= Math.pow(2, s) - 1; val++) 
{
// temp list for storing the current subset
ArrayList<Integer> tmp = new ArrayList<>();

// Check the ith bit-value of num
for (int j = 0; j <= s - 1; j++) {

// If ith bit is ON, adding arr[i] to temporary subset
if ((val & (1 << j)) == (1 << j)) 
{
tmp.add(inputArrList.get(j));
}

}

// add the tmp subset to the answer list
answer.add(tmp);
}

// Printing the final answer
for (int i = 0; i < answer.size(); i++) 
{
// Sorting and printing each subset
Collections.sort(answer.get(i));
System.out.print("[ ");
for (int j = 0; j < answer.get(i).size(); j++) 
{
System.out.print(answer.get(i).get(j) + " ");
}
System.out.print("]");
System.out.println( );
}



}



// a method that generates all the subsets of the input list
private void getSubsets(int i, ArrayList<Integer> tmp, ArrayList<ArrayList<Integer>> answer, ArrayList<Integer> inputArrList) 
{

// handling the base case
if (i == inputArrList.size()) 
{
// including the generated current subset (which is non empty) to the 2D list answer
if (tmp.size() > 0) 
{
answer.add(tmp);
}
return;
}

// Invoking the subset that has the ith array element inside it
ArrayList<Integer> tmp1 = new ArrayList<>(tmp);
tmp1.add(inputArrList.get(i));
getSubsets(i + 1, tmp1, answer, inputArrList);

// Generating the subset that will not contain the ith array element 
getSubsets(i + 1, tmp, answer, inputArrList);
}

// main method
public static void main(String argvs[]) 
{

// creating an object of the class SubsetIntArr1
SubsetIntArr1 obj = new SubsetIntArr1();

// creating an object of the class ArrayList
ArrayList<Integer> arrList = new ArrayList<Integer>(); 

// input 1
for (int j = 1; j <= 3; j++)
{
arrList.add(j);
}

System.out.println("For the array list: " + arrList + " \n");

System.out.println("The subsets are: ");

obj.displayAllSubsets(arrList.size(), arrList );

System.out.println();

arrList.clear();

// input 2
for (int j = 1; j <= 5; j++)
{
arrList.add(j);
}

System.out.println("For the array list: " + arrList + " \n");

System.out.println("The subsets are: ");

obj.displayAllSubsets(arrList.size(), arrList );



}
}

Output:

For the array list: [1, 2, 3] 

The subsets are: 
[ 1 ]
[ 2 ]
[ 1 2 ]
[ 3 ]
[ 1 3 ]
[ 2 3 ]
[ 1 2 3 ]

For the array list: [1, 2, 3, 4, 5] 

The subsets are: 
[ 1 ]
[ 2 ]
[ 1 2 ]
[ 3 ]
[ 1 3 ]
[ 2 3 ]
[ 1 2 3 ]
[ 4 ]
[ 1 4 ]
[ 2 4 ]
[ 1 2 4 ]
[ 3 4 ]
[ 1 3 4 ]
[ 2 3 4 ]
[ 1 2 3 4 ]
[ 5 ]
[ 1 5 ]
[ 2 5 ]
[ 1 2 5 ]
[ 3 5 ]
[ 1 3 5 ]
[ 2 3 5 ]
[ 1 2 3 5 ]
[ 4 5 ]
[ 1 4 5 ]
[ 2 4 5 ]
[ 1 2 4 5 ]
[ 3 4 5 ]
[ 1 3 4 5 ]
[ 2 3 4 5 ]
[ 1 2 3 4 5 ]

Complexity Analysis: The time, as well as space complexity of the program is the same as the previous program.

Next TopicDigit Count in a Factorial Of a Number in Java

← prev next →