Java 中的 CAR Hoare Quicksort 实现

Question

我正在尝试对整数数组实施 QuickSort。

除了分区之外，我所有的方法都可以正常运行。 分区从获取中点开始，然后排序，首先，中间，最后。

出来 {1,6,5,4,3,2,7}

然后在这之后的某个地方我得到 {1, 2, 5, 3, 4, 7, 6} 作为最终结果

谁能告诉我哪里可以调整？

预期输出应为 {1,2,3,4,5,6,7}

import java.util.Arrays;

public class Test {
    public static void main(String[]args) {


    int [] a = {7,6,5,4,3,2,1};

    quickSort(a);

    System.out.println(Arrays.toString(a));

}

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

    public static void quickSort(int [] a,int start,int end) { 
        if(start<end) {
            int pivotIndex = partition(a, start, end);
            quickSort(a,start,pivotIndex-1); // sort left partition
            quickSort(a,pivotIndex+1,end); // sort right partition
        }

    }

    public static  int partition(int [] a, int start, int end) {
        int mid =midpoint(start,end);
        sortFirstMiddleLast(a,start,mid,end);


        swap(a,start,end-1);
        int pivotIndex = end -1;
        int pivotValue = pivotIndex;

        int indexFromLeft = start +1;
        int indexFromRight = end -2;
        boolean done = false;
        while (!done) {
            while (a[indexFromLeft]<a[pivotValue]) {
                indexFromLeft++;
            }
            while (a[indexFromRight]>a[pivotValue]) {
                indexFromRight--;
            }
            if (indexFromLeft < indexFromRight) {
                swap(a,indexFromLeft,indexFromRight);
                indexFromLeft++;
                indexFromRight--;
            }
            else {
                done=true;
            }

        }
        swap(a,pivotIndex,indexFromLeft);
        pivotIndex=indexFromLeft;
        return pivotIndex;
    }

    public static void sortFirstMiddleLast(int [] a, int start, int mid, int end) {
        if (a[start]>a[mid]) {
            swap(a,start,mid);
        }
        else if (a[mid]>a[end]) {
            swap(a,mid,end);
        }
        else if (a[start]>a[end]) {
            swap(a,start,end);
        }
        else if(a[start] > a[mid]) {
            swap (a,start,mid);
        }

    }
    private static void swap(int[] a, int first, int second) {
        int temp = a[first];
        a[first] = a[second];
        a[second] = temp;
    }



    private static int midpoint(int first, int last) {
        return first + (last - first) / 2;
    }
}

Answer 1

检查是否开始 =< array.size -1 和 end >= 0 在行之后执行进一步：

int indexFromLeft = start +1;
int indexFromRight = end -2;

在该条件下终止递归。

Answer 2

如果您使用下面创建的类，就不会有任何问题。

class QuickSort{
int partition(int arr[], int low, int high)
{
    int pivot = arr[high]; 
    int i = (low-1); 
    for (int j=low; j<high; j++)
    {

        if (arr[j] <= pivot)
        {
            i++;


            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }


    int temp = arr[i+1];
    arr[i+1] = arr[high];
    arr[high] = temp;

    return i+1;
}

void sort(int arr[], int low, int high)
{
    if (low < high)
    {

        int pi = partition(arr, low, high);

        sort(arr, low, pi-1);
        sort(arr, pi+1, high);
    }
}

Answer 3

试试这个

       swap(a,start,end-1);
            int pivotIndex = end -1; // removed -1
            int pivotValue = pivotIndex;

            int indexFromLeft = start +1; // removed +1
            int indexFromRight = end -2;  // removed -2 

  public static  int partition(int [] a, int start, int end) {
            int mid =midpoint(start,end);
            sortFirstMiddleLast(a,start,mid,end);


            swap(a,start,end-1);
            int pivotIndex = end ;
            int pivotValue = pivotIndex;

            int indexFromLeft = start ;
            int indexFromRight = end;
            boolean done = false;
            while (!done) {
                while (a[indexFromLeft]<a[pivotValue]) {
                    indexFromLeft++;
                }
                while (a[indexFromRight]>a[pivotValue]) {
                    indexFromRight--;
                }
                if (indexFromLeft < indexFromRight) {
                    swap(a,indexFromLeft,indexFromRight);
                    indexFromLeft++;
                    indexFromRight--;
                }
                else {
                    done=true;
                }

            }
            swap(a,pivotIndex,indexFromLeft);
            pivotIndex=indexFromLeft;
            return pivotIndex;
        }