Java 为名称数组创建快速排序

因此，我正在为我的类做一个项目，目前我正在创建一个快速排序类来对1000个名称的数组进行排序。我有一个模板，我使用的是我们在课堂上做的一个实验，我们应该以此为基础；但在实验室里，我们使用了一个整数数组，我正在努力研究如何将它转换成字符串；名字。感谢您的帮助或任何建议，代码如下

更新后的员额；所以我在我的名字课上做了比较

 public int compareTo(Object other) {
        int result;
        if (name.equals(((Name) other).name))
            result = name.compareTo(((Name) other).name);
        else
            result = name.compareTo(((Name) other).name);

        return result;
    }

我试着重新整理我的快速排序。我正在努力使用交换方法

    private ArrayList<Name> data;

public QuickSort(ArrayList<Name> initialValue){

    data=initialValue;
}

public void sort(ArrayList<Name> namelist, int i, int j){

    sort(0, data.size()-1);
}

public void sort(int from, int to){

    if (from >= to)
        return;
    int p = partition(from, to);
    sort(from, p);
    sort( p + 1, to);
}

private int partition(int from, int to){

    Name pivot = data.get(from);
    int i = from - 1;
    int j = to + 1;

    while(i<j){

        i++; while(data.get(i).compareTo(pivot) < 0) i++;
        j--; while(data.get(j).compareTo(pivot) < 0) j--;
        if(i<j) swap(i,j);

    }

    return j;
}

private void swap (int i, int j){

    Name temp = data.get(i);
    data.equals(i) = data.get(j);
    data = temp;

}

---

可能吗？

您可以使用比较器：comparator。如果对象较小、相等或较大，则compare（o1、o2）返回-1、0或1

java中的字符串实际上是可比较的，某种程度上是一种伴随接口：

 int compareTo(T other);

---

API Do:

发布解决问题的代码很容易，但不会帮助您了解快速排序（或其他排序算法）的含义

快速排序的核心是在此处交换元素：

while(i<j){
    i++; while(data[i] < pivot) i++;
    j--; while(data[j] > pivot) j--;
    if(i<j) swap(i,j);
}

在快速排序中使用它

pivot.compareTo(...);

NameComparator nameComparator = new NameComparator();
nameComparator.compare(..., ...);

使用接口的实例。为此，您将使用

Comparator#compare

。一个基本的示例实现：

public class Name implements Comparable<Name> {
    @Override
    public int compareTo(Name name) {
        return ... //comparison logic...
    }
}

public class NameComparator implements Comparator<Name> {
    @Override
    public int compare(Name name1, Name name2) {
        return ... //comparison logic...
    }
}

---

请注意，字符串内比较是通过相等方法进行的：

data.get(j) == pivot => data.get(j).equals(pivot)

---

您必须设置一个字符串值以将其与其他内容进行比较。因此，通过设置pivot值将其与自身进行比较，它将返回零。由于不太可能所有字符串都等于pivot值，因此与pivot值相比的任何内容都将返回为-1或1。通过这样做，if语句将确定交换值的发送方式（更高或更低），而不是枢轴值

    ObjectQuickSorter sortStrings = new ObjectQuickSorter();
    sortStrings.sort(arrayHere);

    class ObjectQuickSorter{

    void sort(String[] array){
        doQuickSort(array, 0, array.length -1);
    }

    private static void doQuickSort(String[] array,int start, int end){
        int pivotPoint;

        if(start < end){
            pivotPoint = partition(array, start, end);

            doQuickSort(array, start, pivotPoint -1);

            doQuickSort(array, pivotPoint + 1, end);
        }
    }

    private static int partition(String[] array, int start, int end){
        String pivotValue;
        int endOfLeftList;
        int mid = (start + end)/2;

        swap(array, start, mid);

        pivotValue = array[start];

        endOfLeftList = start;

        for(int scan = start + 1; scan <= end; scan++){
            // trying to compare pivot = string value to array[scan] position value
            // doing this by setting pivot value compare to itself to return 0
            // then also comparing pivot value to array[scan] to return -1, 0, 1
            // if return is 0 or 1 then it ignores it
            if(  array[scan].compareTo(pivotValue) < array[start].compareTo(pivotValue)){
                endOfLeftList++;
                swap(array, endOfLeftList,scan);
            }
        }

        swap(array, start, endOfLeftList);

        return endOfLeftList;
    }

    private static void swap(String[] array, int a, int b){
        String temp;

        temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
}

ObjectQuickSortString=new ObjectQuickSorter（）；
sortStrings.sort（arrayHere）；
类ObjectQuickSorter{
无效排序（字符串[]数组）{
doQuickSort（数组，0，array.length-1）；
}
私有静态void doQuickSort（字符串[]数组，int start，int end）{
int轴点；
如果（开始<结束）{
数据透视点=分区（数组、开始、结束）；
doQuickSort（数组、开始、数据透视点-1）；
doQuickSort（数组，数据透视点+1，结束）；
}
}
私有静态整型分区（字符串[]数组，整型开始，整型结束）{
字符串数据透视值；
内隐列表；
int mid=（开始+结束）/2；
交换（阵列、开始、中间）；
数据透视值=数组[开始]；
endoftlist=开始；
对于（int scan=start+1；scan我们的教授希望我们创建一个快速排序类来完成这项工作；据我所知，我们不能使用比较器。这是一种从头开始构建方法的练习。比较器只是比较对象的抽象。一个对象可以由外部比较器进行比较，或者对象可以自己进行比较，就是这样对于字符串。我相信您可以使用它，否则您将不得不实现与快速排序无关的字符串比较。两个字符串之间的相等性测试是使用equals方法完成的，而不是像您在NameTester中的while循环体中所做的那样，在newCommand==“N”…应该是newCommand.equalsIgnoreCase（“N”）while（data[i]while（data.get（i）.compareTo（pivot）<0）compareTo返回一个int。请查看指向API文档的链接。谢谢，我目前正在查看API文档链接。那么我是否需要一个compareTo方法，我需要在我的Name类中编写它？@user2514769这是一个可能性。为了使它更简单，只需使您的
Name
类实现
Comparable
接口，强制您实现他将
compareTo
方法。@user2514769答案已更新。请注意，我没有为比较提供真正的逻辑，因为这同样意味着要为您完成作业。哈，那很好；不介意做作业只是想让我的头绕着它转！也许可以添加一些文本？
    ObjectQuickSorter sortStrings = new ObjectQuickSorter();
    sortStrings.sort(arrayHere);

    class ObjectQuickSorter{

    void sort(String[] array){
        doQuickSort(array, 0, array.length -1);
    }

    private static void doQuickSort(String[] array,int start, int end){
        int pivotPoint;

        if(start < end){
            pivotPoint = partition(array, start, end);

            doQuickSort(array, start, pivotPoint -1);

            doQuickSort(array, pivotPoint + 1, end);
        }
    }

    private static int partition(String[] array, int start, int end){
        String pivotValue;
        int endOfLeftList;
        int mid = (start + end)/2;

        swap(array, start, mid);

        pivotValue = array[start];

        endOfLeftList = start;

        for(int scan = start + 1; scan <= end; scan++){
            // trying to compare pivot = string value to array[scan] position value
            // doing this by setting pivot value compare to itself to return 0
            // then also comparing pivot value to array[scan] to return -1, 0, 1
            // if return is 0 or 1 then it ignores it
            if(  array[scan].compareTo(pivotValue) < array[start].compareTo(pivotValue)){
                endOfLeftList++;
                swap(array, endOfLeftList,scan);
            }
        }

        swap(array, start, endOfLeftList);

        return endOfLeftList;
    }

    private static void swap(String[] array, int a, int b){
        String temp;

        temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
}