如何对存储在不同数组中的数据应用气泡排序

Question

我可以根据编号对下面的代码进行排序吗？

就像数据被排序一样，假设升序应该如下所示：

001  Graciella
012  Steven
094  Marcellin

... and so on 

我的代码：

String [][] sis = new String [][] {
    {"001",  "980", "777", "169","094","233", "012"},
    {"Graciella","Martinus","Renata","Vianney","Marcellin", "Joakim", "Steven"}
};      

System.out.println(sis[0][0]+" "+ sis[1][0]);
System.out.println(sis[0][1]+" "+ sis[1][1]);
System.out.println(sis[0][2]+" "+ sis[1][2]);
System.out.println(sis[0][3]+" "+ sis[1][3]);
System.out.println(sis[0][4]+" "+ sis[1][4]);
System.out.println(sis[0][5]+" "+ sis[1][5]);
System.out.println(sis[0][6]+" "+ sis[1][6]);

我试过以下方法，但我觉得我做错了什么。但我不知道是什么。

String num [] = {"001", "980", "777", "169", "094", "233", "012"};
int NUM [] = new int[num.length];
        
for (int i = 0; i < NUM.length;i++) {
    NUM[i] = Integer.parseInt(num[i]);
}
        
String nem [] = {"Graciella","Martinus","Renata","Vianney","Marcellin", "Joakim", "Steven"};
        
        
for (int i = 0; i < 6; i++) {
    for(int j = 0; j < 6; j++) {
        if (num[j].compareTo(num[j+1]) > 0) {
            String temp = num[j];
            num[j] = num[j+1];
            num[j+1]= temp;
        }
    }
}
        
System.out.println();
        
for (int i = 0; i < 6; i++) {
    for(int j = 0; j < 6; j++) {
        if (nem[j].compareTo(nem[j+1]) > 0) {
            String temp = nem[j];
            nem[j] = nem[j+1];
            nem[j+1]= temp;
        }
    }
}

for (int j = 0; j < 6; j++) {
    System.out.println(num[j] + " " + nem[j]);
}

你能告诉我我做错了什么吗？我可以根据名称对这些数据进行排序吗？

Answer 1

我在代码中添加了注释以进行解释。我没有包括一些最佳代码实践（即不要重复代码），我只是专注于算法。

同样最简单的方法是首先创建将两个字符串（数字和名称）连接在一起的新数组，然后对这个额外的数组进行排序。但是我不知道你是否因为其他原因需要对原始数组进行排序，因此我保持原样。

    for (int i = 0; i < 6; i++) {
        for(int j = 0; j < 6; j++) {
            if (num[j].compareTo(num[j+1]) > 0) {                   
                String temp = num[j];
                num[j] = num[j+1];
                num[j+1]= temp;

                // You need to switch this as well as you keep it as pair, so it has to be
                // in same position after shift

                temp = nem[j];
                nem[j] = nem[j+1];
                nem[j+1]= temp;
            }
        }
    }
    
    System.out.println();
    
    for (int i = 0; i < 6; i++) {
        for(int j = 0; j < 6; j++) {
            // only if the number is the same, then check which string has priority
            if (nim[j] == nim[j+1] && nem[j].compareTo(nem[j+1]) > 0) {
                String temp = nem[j];
                nem[j] = nem[j+1];
                nem[j+1]= temp;

                // You need to keep the other array in sync
                temp = num[j];
                num[j] = num[j+1];
                num[j+1]= temp;
            }
        }
    }

Answer 2

正如@Elliott Frisch在评论中指出的那样，如果将这些数据视为对象，而不是将Person属性分散在两个不同的数组中，则会更容易和更清晰，这会使您的解决方案变得脆弱和不灵活。

这就是Person类的样子：

public class Person {
    private int id;
    private String name;
    
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    
    public int getId() {
        return id;
    }
    
    public String getName() {
        return name;
    }
    
    @Override
    public String toString() {
        return String.format("%03d %s", id, name);
    }
}

这就是我们如何实现冒泡排序。

注意：不需要遍历嵌套循环中的孔数组（条件<代码>j

此外，硬编码值，如条件<代码>j中的值

public static void sortPeopleWithBubbleSort(Person[] people) {
    for (int i = 0; i < people.length; i++) {
        for (int j = 0; j < people.length - 1 - i; j++) {
            if (people[j].getId() > people[j + 1].getId()) {
                Person temp = people[j + 1];
                people[j + 1] = people[j];
                people[j] = temp;
            }
        }
    }
}

main（）

public static void main(String[] args) {
    Person[] people = new Person[]{
        new Person(1, "Graciella"),
        new Person(980, "Martinus"),
        new Person(777, "Renata"),
        new Person(169, "Vianney"),
        new Person(94, "Marcellin"),
        new Person(233, "Joakim"),
        new Person(12, "Steven")
    };
    // sorting
    sortPeopleWithBubbleSort(people);
    // printing
    for (Person person: people) {
        System.out.println(person);
    }
}

输出：

001 Graciella
012 Steven
094 Marcellin
169 Vianney
233 Joakim
777 Renata
980 Martinus

正如@hfontanez在评论中所建议的那样，我们可以通过提供额外的参数-比较器（用于比较没有自然顺序的对象的特殊对象），使sortPeopleWithBubbleSort（）方法更加灵活。

它可能看起来像这样：

// sorting by id
Comparator<Person> byId = Comparator.comparingInt(Person::getId);

sortPeopleWithBubbleSort(people, byId);

// sorting by name
Comparator<Person> byName = Comparator.comparing(Person::getName);

sortPeopleWithBubbleSort(people, byName);

public static void sortPeopleWithBubbleSort(Person[] people,
                                            Comparator<Person> comparator) {
    
    for (int i = 0; i < people.length; i++) {
        for (int j = 0; j < people.length - 1 - i; j++) {
            if (comparator.compare(people[j], people[j + 1]) > 0) {
                Person temp = people[j + 1];
                people[j + 1] = people[j];
                people[j] = temp;
            }
        }
    }
}

要了解如何使用Java-8方法构建比较器，请查看这篇文章。如果您对Java8个函数式编程特性不满意，最好从本教程开始。