Java 多维数组的快速排序

编辑：我希望此方法根据用户想要的任何列按升序排序（同一行中的每个数据都彼此“附加”）。表中有4列。如果用户希望根据第一列进行排序，那么他应该执行以下操作

mySortedTable[][] = ClassName.quickSort(myUnsortedTable,0); 

正如你所看到的，我试图把我的标题写下来。出于某种原因，我们的数据表被组织在一个2d字符串数组中（这并不方便，必须来回转换才能实现ArrayList）。我使用第一个数据作为轴心。介意和我一起调试吗？：）

公共静态字符串[][]快速排序（字符串[][]数据，int列）{
//第一步，创建所需的ArrayList并通过pivot比较数据，以确定要填充的ArrayList。
ArrayList hiData=新的ArrayList（）；
ArrayList loData=新的ArrayList（）；
ArrayList pivots=新的ArrayList（）；
字符串[]pivot={data[0][0]，data[0][1]，data[0][2]，data[0][3]}；
for（字符串[]行：数据）{
if（行[列].compareTo（轴[列]）0）
添加（行）；
else枢轴。添加（行）；
}
//决定是否需要从ArrayList创建数组，以便对分离的数据进行递归排序。
如果（loData.size（）>0）{
字符串[][]loDataArr=新字符串[loData.size（）][4]；
对于（int i=0；i1）
loDataArr=快速排序（loDataArr，列）；
}
如果（hiData.size（）>0）{
字符串[][]hiDataArr=新字符串[hiData.size（）][4]；
对于（int i=0；i1）
HIDATARR=快速排序（HIDATARR，列）；
}
//将分离的数据合并到新数组中，并返回它以向上反馈递归，直到第一次递归调用。
字符串结果[][]=新字符串[hiData.size（）+loData.size（）+pivots.size（）][4]；
int j=0；
对于（字符串[]行：loData）{
结果[j]=行；
j++；
}
对于（字符串[]行：枢轴）{
结果[j]=行；
j++；
}
for（字符串[]行：hiData）{
结果[j]=行；
j++；
}
返回结果；
}

---

它输出所有数组，但未排序，也不等于它开始使用的数组。还有一个附带的问题，我想问的是，

ArrayList

是否闻起来不好闻，或者是吗？

在Java中，数组总是一维的，尽管它们的元素类型可能是数组本身。所以Java中的二维数组就是数组的数组

当您想要对数组进行排序以使行粘在一起时，这一事实变得非常方便。将每一行视为一个对象，并使用比较器来比较该对象

下面是一个小演示：

public class SortDemonstration {

    public static void main(String[] args) {

        String[][] table = {
                {"The", "Quick",  "Brown"},
                {"Fox", "Jumped", "Over"},
                {"A",   "Lazy",   "Dog"}
            };

        Arrays.sort( table, new ColumnComparator(0));
        System.out.println( Arrays.deepToString(table));

        Arrays.sort( table, new ColumnComparator(1));
        System.out.println( Arrays.deepToString(table));

        Arrays.sort( table, new ColumnComparator(2));
        System.out.println( Arrays.deepToString(table));
    }

    private static class ColumnComparator implements Comparator<String []>{
        private final int index;
        public ColumnComparator(int index) {
            this.index = index;
        }
        @Override
        public int compare(String[] o1, String[] o2) {
            return o1[index].compareTo(o2[index]);
        }

    }

}

---

我在代码中发现了问题。我使用未排序的ArrayList而不是排序的二维数组来构建分割数据

//Second step... 
        String[][] loDataArr = new String[loData.size()][4];
        String[][] hiDataArr = new String[hiData.size()][4];
        if(loData.size()>0) {
            for(int i=0;i<loData.size();i++)
                loDataArr[i]=loData.get(i);
            if(loData.size()>1)
                loDataArr = quickSort(loDataArr,column);
        }
        if(hiData.size()>0) {   
            for(int i=0;i<hiData.size();i++)
                hiDataArr[i]=hiData.get(i);
            if(hiData.size()>1)
                hiDataArr = quickSort(hiDataArr,column);
        }
        String result[][] = new String[hiData.size()+loData.size()+pivots.size()][4];
        int j=0;
        for(String[] row : loDataArr) {
            result[j]=row;
            j++;
        }
        for(String[] row : pivots) {
            result[j]=row;
            j++;
        }
        for(String[] row : hiDataArr) {
            result[j]=row;
            j++;
        }
        return result;
    }

//第二步。。。
字符串[][]loDataArr=新字符串[loData.size（）][4]；
字符串[][]hiDataArr=新字符串[hiData.size（）][4]；
如果（loData.size（）>0）{
对于（int i=0；i1）
loDataArr=快速排序（loDataArr，列）；
}
如果（hiData.size（）>0）{
对于（int i=0；i1）
HIDATARR=快速排序（HIDATARR，列）；
}
字符串结果[][]=新字符串[hiData.size（）+loData.size（）+pivots.size（）][4]；
int j=0；
对于（字符串[]行：loDataArr）{
结果[j]=行；
j++；
}
对于（字符串[]行：枢轴）{
结果[j]=行；
j++；
}
对于（字符串[]行：HIDATARR）{
结果[j]=行；
j++；
}
返回结果；
}

您希望如何对其进行排序？好像是一个长数组？每列都排序了吗？每行排序？编辑以回答您的问题。谢谢：）您为什么要自己实现而不是使用现有的工具，如

Arrays.sort（）

？@realponsign它只对单个数组进行排序，不是吗？我的数据表是二维的。每一行都是一个结构（抽象地）。数据[行][0]中的字符串已“连接”到数据[行][1]、数据[行][2]、数据[行][3]。如果你对他们中的一个进行排序，你也必须把他们的朋友放在相应的位置。啊，为什么我没有想到使用comparator/comparable。虽然在我的代码和实现中并没有真正正确地解决这个问题，但谢谢。如果没有人能找到我的代码错误，将在给定时间内标记为应答。 [[A, Lazy, Dog], [Fox, Jumped, Over], [The, Quick, Brown]] [[Fox, Jumped, Over], [A, Lazy, Dog], [The, Quick, Brown]] [[The, Quick, Brown], [A, Lazy, Dog], [Fox, Jumped, Over]]

//Second step... 
        String[][] loDataArr = new String[loData.size()][4];
        String[][] hiDataArr = new String[hiData.size()][4];
        if(loData.size()>0) {
            for(int i=0;i<loData.size();i++)
                loDataArr[i]=loData.get(i);
            if(loData.size()>1)
                loDataArr = quickSort(loDataArr,column);
        }
        if(hiData.size()>0) {   
            for(int i=0;i<hiData.size();i++)
                hiDataArr[i]=hiData.get(i);
            if(hiData.size()>1)
                hiDataArr = quickSort(hiDataArr,column);
        }
        String result[][] = new String[hiData.size()+loData.size()+pivots.size()][4];
        int j=0;
        for(String[] row : loDataArr) {
            result[j]=row;
            j++;
        }
        for(String[] row : pivots) {
            result[j]=row;
            j++;
        }
        for(String[] row : hiDataArr) {
            result[j]=row;
            j++;
        }
        return result;
    }