内部リストの長さが可変である整数のArrayListsのArrayListのソート

Question

Ques：異なる整数の集合Sが与えられれば、可能なすべてのサブセットを返します。サブセット内の要素は降順でない必要があります。また、サブセットは昇順（辞書順）順にソートする必要があります。
私のアプローチ：入力を最初にソートしました。次に、すべてのサブセットを見つけ、各ステップで見つかった新しいサブセットを「res」に追加しました。今私はカスタムコンパレータを使用して "res" arraylistをソートしようとしました。しかし、出力は間違っています。 ArrayListの入力の場合
a={ 15, 12, 4 }
出力：res={ {}, {4}, {4,12}, {4,15}, {4,12,15}, {12}, {12,15}, {15} }
予想される出力：res={ {}, {4}, {4,12}, {4,,12,15}, {4,15}, {12}, {12,15}, {15} }

public static ArrayList<ArrayList<Integer>> subsets(ArrayList<Integer> a) 
{ int i,j; 
    ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>(); 
    ArrayList<Integer> temp; 
    res.add(new ArrayList<Integer>());   
    Collections.sort(a); 
    for(i=0;i<a.size();i++) 
    { ArrayList<ArrayList<Integer>> str=new ArrayList<ArrayList<Integer>>(); 
     for(ArrayList<Integer> al:res) 
     { temp=new ArrayList<Integer>(); 
      temp.addAll(al); 
      temp.add(a.get(i));    
      str.add(temp); 
     } 
     res.addAll(str); 

    } 
    Collections.sort(res,new Comparator<ArrayList<Integer>>() 
    { public int compare(ArrayList<Integer> p,ArrayList<Integer> q) 
     { if(q.size()==0) 
       return 1; 
      else       
       return Integer.compare(p.get(0),q.get(0)); 
     } 
    }); 
    return res; 
} 

は、私がこのコンパレータを書いて、互いに対して、内側のリストをソートします。しかしコンパレータは間違った答えを出しています。私は私のコンパレータが間違って書かれていると思います。

Answer 1

あなただけのリストの最初の要素を比較すべきではありません。 2つのリストを同じ最初の要素で比較すると、何が起こりますか？

問題を軽減するには、差異に達するまで各要素を比較する必要があります。私は以下を提案します：

int oneSize = listOne.size(); 
int twoSize = listTwo.size(); 

for(int i = 0; i < oneSize; i++) 
{ 
    if(i == oneSize || i == twoSize) 
     return oneSize - twoSize; 

    int elementOne = listOne.get(i); 
    int elementTwo = listTwo.get(i); 
    if(elementOne == elementTwo) 
     continue; 

    return Integer.compare(elementOne, elementTwo); 
} 

Answer 2

内側のリストを個別にソートしてから外側のリストをソートする必要があります。

以下のコードスニペットが私にとって役立ちました。

Collections.sort(res, new Comparator<List<Integer>>() { 

      @Override 
      public int compare(List<Integer> p, List<Integer> q) { 

       Collections.sort(p); 
       Collections.sort(q); 

       return Integer.compare(p.get(0),q.get(0)); 
      } 
     }); 

出力：

Before Sorting 
[12, 15] 
[25, 15] 
[10, 12, 25] 
After Sorting 
[10, 12, 25] 
[12, 15] 
[15, 25] 

編集：

私のために働いた以下のコードを見つけてください。

public class Stack1 { 

    private List<List<Integer>> outerList = null; 
    private List<Integer> innerList = null; 

    public static void main(String args[]) { 
     Stack1 stack1 = new Stack1(); 

     List<Integer> fullList = new ArrayList<>(); 
     fullList.add(15); 
     fullList.add(12); 
     fullList.add(4); 

     stack1.subsetsOfList(fullList); 

     System.out.println("Before Sorting"); 
     stack1.printLists(); 
     stack1.sortLists(); 
     System.out.println("After Sorting"); 
     stack1.printLists(); 
    } 

    public void subsetsOfList(List<Integer> a) { 
     int i, j; 
     outerList = new ArrayList<>(); 
     outerList.add(new ArrayList<Integer>()); 
     Collections.sort(a); 
     for (i = 0; i < a.size(); i++) { 
      List<List<Integer>> str = new ArrayList<>(); 
      for (List<Integer> al : outerList) { 
       innerList = new ArrayList<>(); 
       innerList.addAll(al); 
       innerList.add(a.get(i)); 
       str.add(innerList); 
      } 
      outerList.addAll(str); 
     } 
    } 

    public void printLists() { 
     for (List<Integer> list : outerList) { 
      System.out.println(list); 
     } 
    } 

    public void sortLists() { 
     Collections.sort(outerList, new Comparator<List<Integer>>() { 
      @Override 
      public int compare(List<Integer> t, List<Integer> t1) { 

       Collections.sort(t); 
       Collections.sort(t1); 

       for(int i = 0; i < t.size(); i++) { 
        if(t.size() > i && t1.size() > i) { 
         int result = Integer.compare(t.get(i), t1.get(i)); 
         if(result != 0) { 
          return result; 
         } 
        } else if (t.size() > i && t1.size() < i) { 
         return 1; 
        } else if (t.size() < i && t1.size() > i) { 
         return -1; 
        } 
       } 

       return 0; 
      } 
     }); 
    } 
} 

出力リレー：

Before Sorting 
[] 
[4] 
[12] 
[4, 12] 
[15] 
[4, 15] 
[12, 15] 
[4, 12, 15] 
After Sorting 
[] 
[4] 
[4, 12] 
[4, 12, 15] 
[4, 15] 
[12] 
[12, 15] 
[15]