排序內部列表長度不等的整數ArrayList的ArrayList

Question

問題：給定一組不同的整數S，返回所有可能的子集。子集中的元素必須以非降序排列。此外，子集應按升序（詞典）順序排序。
我的做法：我首先對輸入進行了排序。然後找到所有子集，並將每個步驟中找到的新子集添加到「res」中。現在我嘗試使用自定義比較器對「res」數組列表進行排序。但輸出錯了。
對於輸入數組列表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

你不應該只是比較列表的第一要素。當你將兩個列表與第一個元素進行比較時，會發生什麼，但在它之後有任意數量的不同元素？

爲了緩解這個問題，您必須比較每個元素，直到達到差異。我會建議如下：

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]