Finding the power set of a generic set

I had been given a question to utilize java generics and create a Set class. I have been able to perform other functions such as union, intersection, complement etc using this Set class.

But the problem i have been facing is with finding all the power sets. I am required to return a set (i.e the power set). I have been trying to solve this since yesterday but to no avail. I have tried implementing binary method to find the power sets. Everything that i have done so far is based on the requirements of the question!

public class Set<T extends Comparable> {

private ArrayList<T> theSet;

public Set(T[] theElements){
    theSet = new ArrayList<>();
    for(int i=0; i < theElements.length; i++){
        if(!checker(theElements[i]))
            theSet.add(theElements[i]);
    }
}

public ArrayList<T> getTheSet() {
    return theSet;
}

public Set powerSet(){
    long powerSetSize = (long)Math.pow(2, theSet.size());
    int counter, j;
    Set[] powerSet = new Set[(int)Math.pow(2, theSet.size())];
    T[] currentArray = null;
    
    for(counter=0; counter<powerSetSize; counter++){
        for(j=0; j<theSet.size(); j++){
            currentArray = (T[]) new Comparable[j+1];
            if((counter & (1 << j)) > 0)
                currentArray[j] = theSet.get(j);
        }
        powerSet
0
+
网站访问量
 = new Set<>(currentArray);
    }
    
    return new Set<>((T[])powerSet);
}

public String toString(){
    String str = "{";
    for(int i=0; i<theSet.size(); i++){
        if(i < theSet.size()-1)
            str += theSet.get(i)+", ";
        else
            str += theSet.get(i)+"}";
    }
    return str;
}

}

You could try the following:

First create and Array of Integers with length of your basic set, setting every Integer to zero. Keep in mind that every Element is numbered due to its position in your basic set +1, because you need an empty Element, which is then zero. Then of course first create a Set of Sets, that you are going to return as your powerset. After that cycle through your array of Integers as follows: Create a Set out of the current Integer-Array by parsing every Integer to its corresponding element of the Set. Then add one to the first Integer of your Integer-Array. If the number is then greater than the length of your basic Set, add one to the next Integer of your Array, setting the "overflowing" Integer equal to the next Integer in the Array +1.

This should allow you to cycle through every possible combination for the powerset and add them to the Set.

public Set<Set<T>> powerSet(){
    int[] num = new int[list.size()];
    Arrays.fill(num,0);
    Set<Set<T>> powerSet = new Set<>();
    do{
        powerSet.list.add(parse(num));
    }while (addNum(num)); //Loops through every possibility 
    powerSet.list.add(parse(num)); 
    //Because the method returns false when this was the last possible increment
    return powerSet;
}

//Transforms a int[] into the corresponding Set
private Set<T> parse(int[] e){
    Set<T> s = new Set<>();
    for (int i = 0; i < e.length; i++) {
        if(e[i]!=0){
            s.list.add(list.get(e[i]-1)); //Every Element has its number
        }
    }
    return s;
}

//Increments the counter
//Returns false if this was the last possible increment
private boolean addNum(int[] e){
    e[0]++;
    for (int i = 0; i < e.length; i++) {
        if(e[i]>e.length-i){
            e[i] = 0;
            e[i+1]++;
        }
    }
    for (int i = e.length-1; i != 0; i--) {
        if(e[i]>=e[i-1]&&e[i]!=0){
            e[i-1] = e[i]+1;
        }
    }
    if(e[e.length-1]==1){
        return false;
    }
    return true;
}

Output for [3,43,65,32] (printed out every Set of the powerset):

[]
[3]
[43]
[65]
[32]
[43, 3]
[65, 3]
[32, 3]
[65, 43]
[32, 43]
[32, 65]
[65, 43, 3]
[32, 43, 3]
[32, 65, 3]
[32, 65, 43]
[32, 65, 43, 3]

Although this may not be the most elegant way of solving the problem, it appears to work. I also don't know the requirements of the question. So maybe this answer isn't even suitable.