如何編寫一個方法，使用通用 Comparable 類型對 java 中的 ArrayList 進行排序

Question

我正在嘗試編寫一種方法來對整數數組進行排序。

該方法必須使用Comparable接口。 我設計了一個測試用例並試圖編寫一個解決方案。

預期的：

Enter 10 integers: 3 4 12 7 3 4 5 6 4 7
The sorted numbers are 3 3 4 4 4 5 6 7 7 12

實際的：

Enter 10 integers: 1
Enter 10 integers: 2
Enter 10 integers: 34
Enter 10 integers: 4
Enter 10 integers: 3
Enter 10 integers: 2
Enter 10 integers: 1
Enter 10 integers: 4
Enter 10 integers: 5
Enter 10 integers: 6
The sorted numbers are: 3 5 4 1 2 2 1 4 5 6

我的嘗試

public class Test2 {
    
    public static void main(String args[]){
        ArrayList<Integer> array = new ArrayList<>();
        Scanner input = new Scanner(System.in);
        for(int i = 0; i < 10; i++){
            System.out.print("Enter 10 integers: ");
            int integer    = input.nextInt();
            array.add(integer);
        }
        sort(array);
        System.out.print("The sorted numbers are ");
        for(int i = 0; i <= array.size()-1; i++){
            System.out.print(array.get(i)+" ");
        }
    }

    public static <E extends Comparable <E>> void sort(ArrayList<E> list) {
        int n = list.size();
    
        for(int  i = 1; i < n-1; i++) {
            for(int j = 0; j < n-i-1; j++) {
                if(list.get(i).compareTo(list.get(i+1)) < 0) {
                    E temp = list.get(i);
                    list.set(j, list.get(j+1));
                    list.set(j + 1, temp);
                }
            }
         }
     }
}

接下來我可以嘗試什么？

Answer 1

它的工作方式不同，因為您可以將值分配給數組的元素。

對於列表，您必須使用方法set() ：

list.set(j + 1, temp);

此外，避免使用ArrayList等具體類型作為方法參數和變量，針對List等接口編寫代碼。 現在，您的方法sort()僅限於接受實例ArrayList並且無法處理LinkedList 。

Answer 2

其實這個邏輯是錯誤的，重復交換並不一定會全部排序。

該代碼不保證涵蓋所有需要交換的對：

public static <E extends Comparable <E>> void sort(List<E> list) {
    int n = list.size();
    for (int  i = 1; i < n-1; i++) { // n-2 i's
        for (int j = 0; j < n-1-i; j++) { // for all i: n-1-i
            if (list.get(i).compareTo(list.get(i+1)) < 0) {
                Collections.swap(i, j+1);
            }
        }
     }
 }

它假定 n-1-i 之后的元素將在后面排序。 特別是最后一個元素 i == n-1 似乎沒有被處理。

更值得信賴：

public static <E extends Comparable <E>> void sort(List<E> list) {
    int n = list.size();
    // INVARIANT list[0, i> is sorted
    for (int  i = 0; i < n; i++) {
        // INVARIANT list[0, i> is sorted

        // INVARIANT list[0, j> is sorted
        // INVARIANT list[j, i> is sorted
        for (int j = 0; j < i; j++) {
            // INVARIANT list[0, j> is sorted
            // INVARIANT list[j, i> is sorted
            if (list.get(i).compareTo(list.get(j)) < 0) {
                Collections.swap(i, j);
                // And greater j's are unsorted w.r.t. j
            }
            // INVARIANT list[j+1, i> is sorted
            // INVARIANT list[0, j+1> is sorted
        }
        // INVARIANT list[0, i+1> is sorted
     }
     // INVARIANT list[0, n> is sorted
 }

您可以檢查前置條件、后置條件、循環變量、不變量和證明。

（兩者）的復雜性是O(n²) ，可以改進，因為 100² 已經是 10_000（5_000 個循環步驟）。

Answer 3

import java.util.ArrayList;
import java.util.Scanner;


public class Exercise19_09 {
    
    public static void main(String args[]){
        ArrayList<Integer> array = new ArrayList<>();
        Scanner input = new Scanner(System.in);
        System.out.print("Enter 10 integers: ");
        for(int i = 0; i < 10; i++){
            int integer    = input.nextInt();
            array.add(integer);
        }
        sort(array);
        System.out.print("The sorted numbers are ");
        for(int i = 0; i <= array.size()-1; i++){
            System.out.print(array.get(i)+" ");
        }
    }

    public static <E extends Comparable <E>> void sort(ArrayList<E> list){
        int n = list.size();
    
        for(int  i = 0; i < n-1; i++){
            for(int j = 0; j < n-i-1; j++)
                if(list.get(j).compareTo(list.get(j+1)) > 0){
                    E temp = list.get(j);
                    list.set(j, list.get(j+1));
                    list.set(j + 1, temp);

                }
        }
    }
}