Question

所以我有这个代码可以按年级快速排序学生名单。

public static void quickSort(Student[] school){
    quickSort(school, 0, school.length - 1);              // quicksort all the elements in the array
}

private static void quickSort(Student[] school, int start, int end) {
    int i = start;                          // index of left-to-right scan
    int k = end;                            // index of right-to-left scan

    if (end - start >= 1) // check that there are at least two elements to sort
    {
        Student pivot = school[start];       // set the pivot as the first element in the partition

        while (k > i) // while the scan indices from left and right have not met,
        {
            while (school[i].getStudentGrade() <= pivot.getStudentGrade() && i <= end && k > i) // from the left, look for the first
            {
                i++;
                                                   // element greater than the pivot
            }
            while (school[k].getStudentGrade() > pivot.getStudentGrade() && k >= start && k >= i) // from the right, look for the first
            {
                k--;                                        // element not greater than the pivot
            }
            if (k > i) // if the left seekindex is still smaller than
            {
                swap(school, i, k);                      // the right index, swap the corresponding elements
            }
        }
        swap(school, start, k);          // after the indices have crossed, swap the last element in
        // the left partition with the pivot 
        quickSort(school, start, k - 1); // quicksort the left partition
        quickSort(school, k + 1, end);   // quicksort the right partition
    } else // if there is only one element in the partition, do not do any sorting
    {
        return;                     // the array is sorted, so exit
    }
}

//Swap 2 index values in array
private static void swap(Student[] school, int index1, int index2)
{
    Student temp = school[index1];           
    school[index1] = school[index2];    
    school[index2] = temp;               
}

我只能弄清楚如何添加额外的排序标准，以便根据我使用student.getStudentNumber获得的学生编号对具有相同成绩的学生进行排序。

Answer 1

不是直接使用比较函数，而是传递java.util.Comparator<T>。这样，您可以针对不同的排序条件实现不同的Comparator。

比较器看起来像这样：

import java.util.Comparator;

public class StudentComparator implements Comparator<Student> {

    @Override
    public int compare(final Student s1, final Student s2) {
        final int gradeDiff = s1.getStudentGrade() - s2.getStudentGrade();
        if (0 != gradeDiff) {
            return gradeDiff;
        }
        final int numberDiff = s1.getStudentNumber() - s2.getStudentNumber();
        if (0 != numberDiff) {
            return numberDiff;
        }
        // addd mor criteria here if wanted
        return 0;
    }
}

Answer 2

现在使用

public class QuickSort {

    public static void quickSort(Student[] school) {
        quickSort(school, 0, school.length - 1);            
    }

    private static void quickSort(Student[] school, int start, int end) {
        int pivotIndex = start;
        int storeIndex = pivotIndex + 1;

        if (end - start >= 1) {

            for (int i = pivotIndex + 1; i <= end; i++) {
                if (school[i].getStudentGrade() > school[pivotIndex].getStudentGrade()) {
                    swap(school, storeIndex, i);
                    storeIndex++;
                } else if(school[i].getStudentGrade() == school[pivotIndex].getStudentGrade()){
                    if(school[i].getStudentNumber() > school[pivotIndex].getStudentNumber()){
                        swap(school, storeIndex, i);
                        storeIndex ++;
                    }
                }
            }
            swap(school, pivotIndex, storeIndex - 1);
            pivotIndex = storeIndex - 1;
            quickSort(school, start, pivotIndex - 1);
            quickSort(school, pivotIndex + 1, end);
        } else {
            return;
        }
    }

    //Swap 2 index values in array

    private static void swap(Student[] school, int index1, int index2) {
        Student temp = school[index1];
        school[index1] = school[index2];
        school[index2] = temp;
    }
}

在java中快速排序中添加额外的排序条件

2 个答案: