Java 如何有效地对多维数组进行排序

我的任务是将多维数组按升序排序，而不使用数组类中预先生成的函数（如.sort）

我试着向我的一些朋友征求意见。。。其中许多方法将数组转换为一维数组，按照对一维数组进行排序的方式对其进行排序，然后将其转换回多维数组

---

我只是想知道是否还有其他方法可以做到这一点，而不必经历这样的麻烦。

这里有一个完整的例子，你可以

import java.util.Arrays;
import java.util.Comparator;

public class PartNumberQuantityDetailer {
// initialize a two dimensional array
static Integer[][] itemIdAndQty = new Integer[5][2];

public static void main(String[] args) {
    // initialize array values
    itemIdAndQty[0][0] = 1234;
    itemIdAndQty[0][1] = 46;
    itemIdAndQty[1][0] = 5443;
    itemIdAndQty[1][1] = 564;
    itemIdAndQty[2][0] = 362;
    itemIdAndQty[2][1] = 24;
    itemIdAndQty[3][0] = 6742;
    itemIdAndQty[3][1] = 825;
    itemIdAndQty[4][0] = 347;
    itemIdAndQty[4][1] = 549;
    System.out.println("Before sorting");
    // show the contents of array
    displayArray();
    // sort the array on item id(first column)
    Arrays.sort(itemIdAndQty, new Comparator<Integer[]>() {
        @Override
                    //arguments to this method represent the arrays to be sorted   
        public int compare(Integer[] o1, Integer[] o2) {
                            //get the item ids which are at index 0 of the array
            Integer itemIdOne = o1[0];
            Integer itemIdTwo = o2[0];
            // sort on item id
            return itemIdOne.compareTo(itemIdTwo);
        }
    });
    // display array after sort
    System.out.println("After sorting on item id in ascending order");
    displayArray();
    // sort array on quantity(second column)
    Arrays.sort(itemIdAndQty, new Comparator<Integer[]>() {
        @Override
        public int compare(Integer[] o1, Integer[] o2) {
            Integer quantityOne = o1[1];
            Integer quantityTwo = o2[1];
            // reverse sort on quantity
            return quantityOne.compareTo(quantityTwo);
        }
    });
    // display array after sort
    System.out.println("After sorting on quantity in ascending order");
    displayArray();

}

private static void displayArray() {
    System.out.println("-------------------------------------");
    System.out.println("Item id\t\tQuantity");
    for (int i = 0; i < itemIdAndQty.length; i++) {
        Integer[] itemRecord = itemIdAndQty[i];
        System.out.println(itemRecord[0] + "\t\t" + itemRecord[1]);
    }
    System.out.println("-------------------------------------");
}

导入java.util.array；
导入java.util.Comparator；
公共类零件号QuantityDetailer{
//初始化二维数组
静态整数[][]itemIdAndQty=新整数[5][2]；
公共静态void main（字符串[]args）{
//初始化数组值
ItemId与数量[0][0]=1234；
ItemId与数量[0][1]=46；
itemIdAndQty[1][0]=5443；
itemIdAndQty[1][1]=564；
ItemId与数量[2][0]=362；
itemIdAndQty[2][1]=24；
itemIdAndQty[3][0]=6742；
itemIdAndQty[3][1]=825；
itemIdAndQty[4][0]=347；
itemIdAndQty[4][1]=549；
System.out.println（“排序前”）；
//显示数组的内容
displayArray（）；
//根据项目id对数组排序（第一列）
Arrays.sort（itemIdAndQty，newcomparator（）{
@凌驾
//此方法的参数表示要排序的数组
公共整数比较（整数[]o1，整数[]o2）{
//获取数组索引0处的项ID
整数itemIdOne=o1[0]；
整数itemIdTwo=o2[0]；
//按项目id排序
返回itemIdOne.compareTo（itemidtow2）；
}
});
//排序后显示数组
System.out.println（“按升序对项目id排序后”）；
displayArray（）；
//按数量排序数组（第二列）
Arrays.sort（itemIdAndQty，newcomparator（）{
@凌驾
公共整数比较（整数[]o1，整数[]o2）{
整数quantityOne=o1[1]；
整数数量2=o2[1]；
//按数量反向排序
返回quantityOne.compareTo（quantityTwo）；
}
});
//排序后显示数组
System.out.println（“按数量升序排序后”）；
displayArray（）；
}
私有静态void displayArray（）{
System.out.println（“-----------------------------------------”；
System.out.println（“项目id\t\tQuantity”）；
对于（int i=0；i

---

}]这里有一个完整的例子，你可以

import java.util.Arrays;
import java.util.Comparator;

public class PartNumberQuantityDetailer {
// initialize a two dimensional array
static Integer[][] itemIdAndQty = new Integer[5][2];

public static void main(String[] args) {
    // initialize array values
    itemIdAndQty[0][0] = 1234;
    itemIdAndQty[0][1] = 46;
    itemIdAndQty[1][0] = 5443;
    itemIdAndQty[1][1] = 564;
    itemIdAndQty[2][0] = 362;
    itemIdAndQty[2][1] = 24;
    itemIdAndQty[3][0] = 6742;
    itemIdAndQty[3][1] = 825;
    itemIdAndQty[4][0] = 347;
    itemIdAndQty[4][1] = 549;
    System.out.println("Before sorting");
    // show the contents of array
    displayArray();
    // sort the array on item id(first column)
    Arrays.sort(itemIdAndQty, new Comparator<Integer[]>() {
        @Override
                    //arguments to this method represent the arrays to be sorted   
        public int compare(Integer[] o1, Integer[] o2) {
                            //get the item ids which are at index 0 of the array
            Integer itemIdOne = o1[0];
            Integer itemIdTwo = o2[0];
            // sort on item id
            return itemIdOne.compareTo(itemIdTwo);
        }
    });
    // display array after sort
    System.out.println("After sorting on item id in ascending order");
    displayArray();
    // sort array on quantity(second column)
    Arrays.sort(itemIdAndQty, new Comparator<Integer[]>() {
        @Override
        public int compare(Integer[] o1, Integer[] o2) {
            Integer quantityOne = o1[1];
            Integer quantityTwo = o2[1];
            // reverse sort on quantity
            return quantityOne.compareTo(quantityTwo);
        }
    });
    // display array after sort
    System.out.println("After sorting on quantity in ascending order");
    displayArray();

}

private static void displayArray() {
    System.out.println("-------------------------------------");
    System.out.println("Item id\t\tQuantity");
    for (int i = 0; i < itemIdAndQty.length; i++) {
        Integer[] itemRecord = itemIdAndQty[i];
        System.out.println(itemRecord[0] + "\t\t" + itemRecord[1]);
    }
    System.out.println("-------------------------------------");
}

导入java.util.array；
导入java.util.Comparator；
公共类零件号QuantityDetailer{
//初始化二维数组
静态整数[][]itemIdAndQty=新整数[5][2]；
公共静态void main（字符串[]args）{
//初始化数组值
ItemId与数量[0][0]=1234；
ItemId与数量[0][1]=46；
itemIdAndQty[1][0]=5443；
itemIdAndQty[1][1]=564；
ItemId与数量[2][0]=362；
itemIdAndQty[2][1]=24；
itemIdAndQty[3][0]=6742；
itemIdAndQty[3][1]=825；
itemIdAndQty[4][0]=347；
itemIdAndQty[4][1]=549；
System.out.println（“排序前”）；
//显示数组的内容
displayArray（）；
//根据项目id对数组排序（第一列）
Arrays.sort（itemIdAndQty，newcomparator（）{
@凌驾
//此方法的参数表示要排序的数组
公共整数比较（整数[]o1，整数[]o2）{
//获取数组索引0处的项ID
整数itemIdOne=o1[0]；
整数itemIdTwo=o2[0]；
//按项目id排序
返回itemIdOne.compareTo（itemidtow2）；
}
});
//排序后显示数组
System.out.println（“按升序对项目id排序后”）；
displayArray（）；
//按数量排序数组（第二列）
Arrays.sort（itemIdAndQty，newcomparator（）{
@凌驾
公共整数比较（整数[]o1，整数[]o2）{
整数quantityOne=o1[1]；
整数数量2=o2[1]；
//按数量反向排序
返回quantityOne.compareTo（quantityTwo）；
}
});
//排序后显示数组
System.out.println（“按数量升序排序后”）；
displayArray（）；
}
私有静态void displayArray（）{
System.out.println（“-----------------------------------------”；
System.out.println（“项目id\t\tQuantity”）；
对于（int i=0；i

---

}]

将多维数组按升序排序：

可以按行或列对多维数组进行排序

如果您不想展平要将其转换为1-d的数组，则这意味着您必须根据您的选择遍历每一行或每一列，并应用快速排序（如果以最佳方式选择pivot，则小型数据集的性能会更好）或合并排序

因此，您可以在（考虑平均情况）中执行这两种操作，即

O（nlogn）

，并假设有n个rown或n个列，时间复杂度将为

O（n^2（logn））

现在，假设您希望按行或列进行排序。 如果您想同时实现（行和列），那么最好将数组转换为一维，然后应用排序，然后再将其转换回来。否则，按照上述方法，时间复杂度可以是

O（n^2（logn））

，但在另一种情况下，时间复杂度将是

O（（n+m）log（n+m））

其中

n

amd

m