冒泡排序对象

Question

我需要使用冒泡排序按名称对我的杂货库存进行排序。

显然，我的代码没有按名称对列表进行排序。
顺便说一句，存储的数据库存来自文件输入。

这是我的代码。

public void sortInventoryByName() {
    //TODO: use bubble sort and compareTo
    int n = inventory.size();
    GroceryItem temp;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (inventory.get(j).compareTo(inventory.get(j + 1)) > 0) {
                temp = inventory.get(i);
                inventory.set(i, inventory.get(i + 1));
                inventory.set(i + 1, temp);
            }
        }
    }
}

这是我的超类 (GroceryItem) 中的 compareTo 方法

@Override
public int compareTo(Object o) {
    if(getClass() != o.getClass()) {
        throw new IllegalArgumentException();
    }
    else {
        GroceryItem other = (GroceryItem) o;
        return (this.name.compareTo(other.name));
    }
}

Answer 1

看起来您在比较正确的值时有些不匹配。

有两种方法可以使用两个 for 循环来实现冒泡排序算法。

下面使第一个循环递增barrier 变量，第二个循环递减index。

因此，在外循环的每次迭代中，最小值将被移动到第一位（就像最小的气泡将首先移动）。下一次迭代将跳过第一个元素。它将持续到列表完整列表结束。

您的示例显示了相反的行为 -> 外部循环的每次迭代都会将列表中的最高元素移到末尾。

您究竟想如何迭代内部 for 循环并不重要。最终的排序结果是我们的目标。

代码sn-p：

public void sortInventoryByName() {
    int n = inventory.size();
    for (int barrier = 0; barrier < n - 1; barrier++) {
        for (int index = n - 2; index >= barrier; index--) {
            if (inventory.get(index).compareTo(inventory.get(index + 1)) > 0) {
                GroceryItem temp = inventory.get(index);
                inventory.set(index, inventory.get(index + 1));
                inventory.set(index + 1, temp);
            }
        }
    }
}

compareTo() 的实现应该可以正常工作。所以，inventory 列表应该正确排序。

根据您的代码的一些注意事项：

• 您不需要在循环之外声明temp 变量。它只是交换两个值的临时变量。内联声明和使用就足够了。

• 建议为循环变量添加更有意义的名称，而不仅仅是i 和j。它增加了未来代码的可读性和理解力

• else 块在compareTo() 是冗余的

@Override
public int compareTo(Object o) {
    if (getClass() != o.getClass()) {
        throw new IllegalArgumentException();
    }
    GroceryItem other = (GroceryItem) o;
    return this.name.compareTo(other.name);
}

Answer 2

我填写了您的代码中缺少的部分。您应该阅读How do I ask a good question 以及指向How to create a Minimal, Reproducible Example 的链接。

下面的代码是GroceryItem 类，它只包含一个成员，即name，它是杂货商品的名称。由于您的问题仅涉及操纵此成员，因此我没有尝试猜测该类还需要哪些其他数据。

代码后的解释。

import java.util.ArrayList;
import java.util.List;

public class GroceryItem implements Comparable<GroceryItem> {
    private String  name;

    public GroceryItem(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override // java.lang.Comparable
    public int compareTo(GroceryItem other) {
        if (other == null) {
            return 1;
        }
        else {
            String otherName = other.getName();
            if (name == null) {
                if (otherName == null) {
                    return 0;
                }
                else {
                    return -1;
                }
            }
            else {
                if (otherName == null) {
                    return 1;
                }
                else {
                    return name.compareTo(otherName);
                }
            }
        }
    }

    @Override // java.lang.Object
    public boolean equals(Object other) {
        boolean equal = false;
        if (other instanceof GroceryItem) {
            GroceryItem otherItem = (GroceryItem) other;
            if (name == null) {
                equal = otherItem.getName() == null;
            }
            else {
                equal = name.equals(otherItem.getName());
            }
        }
        return equal;
    }

    @Override // java.lang.Object
    public int hashCode() {
        return name == null ? 0 : name.hashCode();
    }

    @Override // java.lang.Object
    public String toString() {
        return name;
    }

    public static void main(String[] args) {
        List<GroceryItem> inventory = new ArrayList<>();
        inventory.add(new GroceryItem("apple"));
        inventory.add(new GroceryItem("pear"));
        inventory.add(new GroceryItem("banana"));
        inventory.add(new GroceryItem("orange"));
        inventory.add(new GroceryItem("beetroot"));
        inventory.add(new GroceryItem("onion"));
        inventory.add(new GroceryItem("lettuce"));
        inventory.add(new GroceryItem("carrot"));
        inventory.add(new GroceryItem("guava"));
        inventory.add(new GroceryItem("lychee"));
        inventory.add(new GroceryItem("kiwi"));

        int n = inventory.size();
        for (int i = 0; i < n-1; i++) {
            for (int j = 0; j < n-i-1; j++) {
                if (inventory.get(j).compareTo(inventory.get(j+1)) > 0) {
                    // swap inventory[j+1] and inventory[j]
                    GroceryItem temp = inventory.get(j);
                    inventory.set(j, inventory.get(j+1));
                    inventory.set(j+1, temp);
                }
            }
        }
        System.out.println();
    }
}

上面的代码创建了一个包含十一个元素的GroceryItem 对象的List。填充List 后，冒泡排序 在两个嵌套的for 循环中执行。最后打印出排序后的List。

请注意，GroceryItem 类还实现了方法toString()，以便在打印GroceryItem 的实例时使输出可读。

如果将来您需要使用GroceryItem 作为java.util.HashMap 的键，那么GroceryItem 将需要覆盖方法hashCode()，如果一个类覆盖方法hashCode()，那么它也应该覆盖方法equals()。因此，这就是为什么上面的代码包含那些被覆盖的方法。请注意，这些方法（equals()、hashCode() 和 toString()）都不是冒泡排序所必需的。

运行上述代码时的输出为：

[apple, banana, beetroot, carrot, guava, kiwi, lettuce, lychee, onion, orange, pear]