1

二维数组的选择排序算法是什么？我到处查看并阅读了有关二维数组的信息，但找不到任何简单直接的东西，所以我求助于论坛。（我似乎无法思考如何改变一维数组的类型以使其成为二维数组！！）

例如，这个：

name ----- crime ----- year

name1 ---- arson ----- 1996
name2 ---- theft ----- 2003
name3 ---- arson ----- 1976
name4 ---- theft ----- 2010

变成这样：

name ----- crime ----- year

name1 ---- arson ----- 1996
name3 ---- arson ----- 1976
name2 ---- theft ----- 2003
name4 ---- theft ----- 2010

任何帮助都会很棒！谢谢！

编辑

这是我用于选择排序的代码。他们中的大多数都组织得当，但在几行中，我有“纵火”不属于它，我不确定为什么会这样。这是我的代码：

for(i = 0; i < 10; i++){
        smallest = i;
        for(j = i; j < 10; j++){
            if(criminals[i][1].compareTo(criminals[j][1]) > 0){
                smallest = j;
            }
        }
        temp = criminals[i][1];
        criminals[i][1] = criminals[smallest][1];
        criminals[smallest][1] = temp;
    }

    //output
    for(i = 0; i < 10; i++){
        System.out.println(criminals[i][0] + " - " + criminals[i][1] + " - " + criminals [i][2]);
    }

这是我的输入和输出：

Not sorted list:
Al Capone - arson - 2009
Slippery Sal - theft - 2001
Nada - arson - 1987
Slippery Sal - theft - 1999
Salma - assault - 2010
Scooby Doo - theft - 1998
Velma - assault - 1991
Daphne - arson - 1976
Fred - assault - 2003
Shaggy - arson - 2007
Sorted list (by crime):
Al Capone - arson - 2009
Slippery Sal - arson - 2001
Nada - arson - 1987
Slippery Sal - assault - 1999
Salma - arson - 2010
Scooby Doo - assault - 1998
Velma - assault - 1991
Daphne - theft - 1976
Fred - theft - 2003
Shaggy - theft - 2007
4

4 回答 4

3

对于您的犯罪行为，请执行以下操作：

static final int SORT_BY_NAME = 0;
static final int SORT_BY_CRIME = 1;
static final int SORT_BY_YEAR = 2;

假设：

Object[10][3] = {{"Name", "CRIME", "YEAR"},...};

现在到你的排序算法：

void SelSort(Objects[][] criminals, int sortBy) 
{
    if (criminals == NULL || criminals.length == 0 || sortBy >= criminals[0].length || sortBy < 0)
        return;

    int i,j;
    Object min;

    for (i=0; i < criminals.length ; i++) {
       min = criminals[i][sortBy];
        for (j = i+1; j < criminals.length; j++){
            if (((criminals[j][sortBy].getClass()).cast(min)).compareTo(criminals[j][sortBy]) == 1){//Assuming you can compare them this way else make a method to compare
                Object tmp = criminals[j];
                criminals[j] = criminals[i];
                criminals[i] = tmp;
            }
        }
    }             

}
于 2013-09-20T02:11:24.217 回答
1

好吧，首先，要挑剔，看起来你有一个Criminal对象数组，比如

class Criminal {
    private String name;
    private String crime;
    private int year;
    .
    .
    .
}

然后你会有一个犯罪对象的一维数组。您可以使用常规选择排序算法，但不是比较

criminals[i] < criminals[j]

你会比较

criminals[i].getCrime() < criminals[j].getCrime()

现在，我们不要挑剔，假设您确实有一个二维字符串数组，因此数组的每一行本身就是一个字符串数组。然后只做选择排序，但比较像这样：

criminals[i][1] < criminals[j][1]

这有效，因为

criminals[row][0]   is the name
criminals[row][1]   is the crime
criminals[row][2]   is the year

当你进行交换时，整行都会被交换，你就会得到你想要的。

于 2013-09-20T02:15:18.887 回答
0

根据您的评论，指定的总体排序标准是：在每一行中，必须对元素进行排序。

一次对每个一维数组（二维数组）运行选择排序算法。

于 2013-09-20T02:01:07.300 回答
0

因此，您的二维数组是String[][] array. 然后初始化数组并执行以下操作

for (int i = 0; i < array.length; i++)
{
    int index = i;
    for (int j = i + 1; j < array.length; j++)
    {
        if (array[j][sortByColIndex].compareTo(array[index][sortByColIndex]) < 0)
        {
            index = j;
        }
    }
    String smallerNumber = scores[index][sortByColIndex];
    scores[index][sortByColIndex] = scores[i][sortByColIndex];
    scores[i][sortByColIndex] = smallerNumber;

    // Displaying sorted value
    System.out.print(array[i][0] + "\t" + array[i][1] + "\t" + array[i][2] + "\t");

}
于 2015-03-11T07:59:01.137 回答