创建一个从低到高对数组进行排序的方法

Question

I'm wanting to create a function to sort a two dimensional array, by the score from lowest to highest, but if the score is 0 I don't want to sort it .

I want my array to look like this:

my array:

private int[][] scores = new int[5][2];

the method:

public void sortByScore(){


    scores[0][0] = 0;
    scores[1][0] = 2;
    scores[2][0] = 4;
    scores[3][0] = 6;
    scores[0][1] = 233;
    scores[1][1] = 123;
    scores[2][1] = 542;
    scores[3][1] = 231;

    for(int i=0;i<scores.length-1;i++){

        if(scores[i][0]>scores[i+1][0]){

            int temp =scores[i][0];
            scores[i+1][0]=temp;

            scores[i][0]=scores[i+1][0];


            printArray();
        }


    }

}

Answer 1

I get the impression that you're trying to link a PID value to a numerical score and that you'd like to sort this data so that you get the highest score first. If this is your aim then I think a two-dimensional array is a poor choice of data structure. As an alternative you could create a custom type (class) which pairs the PID and the score to give you a compact object, like this:

public class Score implements Comparable<Score> {
    private int pid;
    private int score;

    public Score(int pid, int score) {
        this.pid = pid;
        this.score = score;
    }

    public int compareTo(Score other) {
        return Integer.compare(this.score, other.score);
    }
}

Now you can create a Score object for each PID like this:

Score alpha = new Score(1, 134);
Score beta = new Score(2, 156);
Score gamma = new Score(3, 121);

Then add them into a NavigableSet which will order them based on their "natural ordering" which is defined by the compareTo method of the Score class:

NavigableSet<Score> scores = new TreeSet<>();
scores.add(alpha);
scores.add(beta);
scores.add(gamma);

Then you can get the scores in order, highest score first, by creating a descending view (starting with highest value first) and then iterating through it like this:

NavigableSet<Score> highestScoresFirst = scores.descendingSet();
for (Score score : highestScoresFirst) {
    // Do something with the current score, such as print it out.
}

There are other ways of doing this, and you could do it with arrays. But I think that the structure you're currently using will be problematic.

Answer 2

This kind of problems are good solved using bubble sort algorithm:

public static void BubbleSort(int[] num) {
    int j;
    boolean flag = true; // set flag to true to begin first pass
    int temp; // holding variable
    while (flag) {
        flag = false; // set flag to false awaiting a possible swap
        for (j = 0; j < num.length - 1; j++) {
            if (num[j] > num[j + 1]) // change to > for ascending sort
            {
                temp = num[j]; // swap elements
                num[j] = num[j + 1];
                num[j + 1] = temp;
                flag = true; // shows a swap occurred
            }
        }
    }
}

this is only an example, you have to adapt it to your requeriments...

More information on this link

Answer 3

Using a Comparator

java.util.Arrays.sort(array, new java.util.Comparator<Integer[]>() {
    public int compare(int[] a, int[] b) {
        return Integer.compare(a[0], b[0]);
    }
});

Answer 4

Since your array only supports the sorting of the scores[i][0] part, the rest parts such as scores[i][1] remains unsorted. As your array is a 2-Dimensional Array, you need 2 for loops for successfully sorting the whole 2D array. So the sorting code should be as below...

//This for loop will move through every part of you 2D Array
int k = 0; //[k][] could be of any from the present array as it just used for the length of sub-array
 for(int i=0;i<scores[k].length-1;i++){ //Length of Sub-array

    for(int j=0;i<scores.length-1;i++) { //Length of Array

        if(scores[j][i]>scores[j+1][i]){

            int temp =scores[j][i];
            scores[j+1][i]=temp;
            scores[j][i]=scores[j+1][i];

            printArray();
        }
    }
}