使用 O(n^2) 排序和比較器實現通用 Java 方法

Question

使用 O(n^2) 排序和比較器實現以下通用 Java 方法：

public static <E> void aSort(E[] list, Comparator<? super E> comparator)

編寫測試程序，創建一個至少包含 5 個以上問題 3 中創建的類類型元素的列表，調用上述方法對列表進行排序，然后通過調用 toString 輸出排序后的列表。

Unsorted: 
A Circle with the radius of: [1]
A Circle with the radius of: [15]
A Circle with the radius of: [10]
A Circle with the radius of: [12]
A Circle with the radius of: [100]

我不知道為什么它會向后打印，但它應該按升序排序

Sorted: 
A Circle with the radius of: [100]
A Circle with the radius of: [12]
A Circle with the radius of: [10]
A Circle with the radius of: [15]
A Circle with the radius of: [1]

這是我到目前為止所得到的

public static void main(String[] args) {

    Circle c1 = new Circle();
    Circle c2 = new Circle(15);
    Circle c3 = new Circle(10);
    Circle c4 = new Circle(12);
    Circle c5 = new Circle(100);

    Circle w[] = new Circle[5];
    w[0] = c1;
    w[1] = c2;
    w[2] = c3;
    w[3] = c4;
    w[4] = c5;

    CompareCircle cc = new CompareCircle();
    System.out.println("Unsorted: ");
    for (Circle go : w) {
        System.out.println(go.toString());
    }

    bubbleSort(w, new CompareCircle());
    System.out.println();
    System.out.println("Sorted: ");
    for (int i = 0; i < w.length; i++) {
        System.out.println(w[i].toString());

    }
   public static <E> void bubbleSort(E[] list, Comparator<? super E> comparator) {
    boolean needNextPass = true;

    for (int k = 1; k < list.length && needNextPass; k++) {
        // Array may be sorted and next pass not needed
        needNextPass = false;
        for (int i = 0; i < list.length - k; i++) {
            if (comparator.compare(list[i], list[i + 1]) > 0) {
                // Swap list[i] with list[i + 1]
                E temp = list[i];
                list[i] = list[i + 1];
                list[i + 1] = temp;

                needNextPass = true; // Next pass still needed
            }
        }
    }

}

}

這是我的 Circle 課程

import java.io.Serializable;
import java.util.Comparator;

public class Circle implements Serializable {

private int radius = 1;

public Circle() {
}

public Circle(int radius) {
    setRadius(radius);

}

public void setRadius(int v) {
    if (v > 0) {
        this.radius = v;
    }

}

public int getRadius() {
    return this.radius;

}

@Override
public String toString() {
    return "A Circle with the radius of: [" + radius + "]";
}


}

這是我的 CompareCircle 類

import java.util.Comparator;

public class CompareCircle implements Comparator<Circle> {

@Override
public int compare(Circle o1, Circle o2) {
    int radius1 = o1.getRadius();
    int radius2 = o2.getRadius();

    if (radius1 < radius2){
        return radius2;
    }
    if (radius1 == radius2){
        return radius1;
    }
    else
        return radius1;
 }

 }

Answer 1

您對bubbleSort實現非常好。 另一方面， CircleComparator格式嚴重錯誤。 無論傳遞哪個Circle它都會返回一個正整數。 因此，在 run n ，第一個元素將被“冒泡”到索引list.length - n ，並且所有剩余的元素（index <= list.length - n ）將被向下推一個索引，最終導致列表被逆轉。

如果第一個值較小，則正確的比較函數將返回負數，如果第二個值較小則返回正數，如果參數相等則返回 0（請參閱文檔）。 例如：

public class CircleCompare implements Comparator<Circle>
{
    public int compare(Circle c1, Circle c2){
        return Integer.compare(c1.getRadius(), c2.getRadius());
    }
}

或者，如果您更喜歡自己執行邏輯，則作為另一種方式：

public class CircleCompare implements Comparator<Circle>
{
    public int compare(Circle c1, Circle c2){
        return c2.getRadius() - c1.getRadius();
    }
}