快速排序多维数组

Question

Edit: I want this method to sort in ascending order based on any column the user want (each data in the same respective row is 'attached' to each other). There are 4 column in the table. if the user want to sort in based on first column then he should do something like

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

As you can see I tried to code what my title said. For some reason our data table is organized in a 2d Array of Strings(which is NOT handy, had to convert back and forth to implement ArrayList). I used the first data as the pivot. Mind debugging it together with me? :)

public static String[][] quickSort(String[][] data,int column) {
    //1st step, create ArrayLists needed and compare the data by the pivot to determine which ArrayList to be filled.
    ArrayList<String[]> hiData = new ArrayList<String[]>();
    ArrayList<String[]> loData = new ArrayList<String[]>();
    ArrayList<String[]> pivots = new ArrayList<String[]>();
    String[] pivot = {data[0][0],data[0][1],data[0][2],data[0][3]};
    for(String[] row : data) {
        if(row[column].compareTo(pivot[column])<0)
            loData.add(row);
        else if (row[column].compareTo(pivot[column])>0)
            hiData.add(row);
        else pivots.add(row);
    }

    //To decide whether is needed to create the array from the ArrayList for recursively sort the parted data.
    if(loData.size()>0) {
        String[][] loDataArr = new String[loData.size()][4];
        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) {   
        String[][] hiDataArr = new String[hiData.size()][4];
        for(int i=0;i<hiData.size();i++)
            hiDataArr[i]=hiData.get(i);
        if(hiData.size()>1)
            hiDataArr = quickSort(hiDataArr,column);
    }

    //Combine parted data into new array and return it to feed the recursive back up until the first recursive call.
    String result[][] = new String[hiData.size()+loData.size()+pivots.size()][4];
    int j=0;
    for(String[] row : loData) {
        result[j]=row;
        j++;
    }
    for(String[] row : pivots) {
        result[j]=row;
        j++;
    }
    for(String[] row : hiData) {
        result[j]=row;
        j++;
    }
    return result;
}

It outputs all the arrays, but is not sorted and also not equals with the arrays it started with. Also side question, I want to ask if ArrayList<String[]> do NOT smells bad, or is it?

Answer 1

In Java, arrays are always one dimensional - although their element type may be an array itself. So a two dimensional array in Java is just an array of arrays.

This fact becomes very handy when you want to sort an array so that rows stick together. You treat each row as an object, and use a comparator to compare the object.

Here is a little demonstration:

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]);
        }

    }

}

The ColumnComparator class is the key to the solution. It implements a comparator of two string arrays (two rows). It compares the rows based on the item at the index it was instantiated with.

Thus a new ColumnComparator(0) compares two rows based on the first column. A new ColumnComparator(1) compares two rows based on the second column, etc.

Now that you have this comparator class, you can sort an array of "rows" using it. The output from this program is:

[[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]]

Answer 2

I found the problem in my code. I built the parted data using the unsorted ArrayList instead of the sorted 2 dimensional array.

//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;
    }