Question

使用O（n ^ 2）排序和比较器实现以下通用Java方法：

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

编写测试程序，创建问题3中创建的类类型的至少5个元素的列表     上面，调用上面的方法对列表进行排序，然后通过调用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将被传递，它将始终返回一个正整数。因此，在运行n中，第一个元素将“冒泡”到索引list.length - n，并且所有剩余元素（索引<= list.length - n）将被推送一个索引，最终导致列表正在被撤销。

正确的比较函数如果第一个值较小则返回负数，如果第二个值较小则返回正数，如果参数相等则返回0（参见documentation）。 E.g：

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();
    }
}

使用O（n ^ 2）排序和比较器

1 个答案: