Java中的Quicksort算法程序

Question

我正在嘗試用Java實現QuickSort算法程序，但我得到了錯誤的答案。

public class QuickSort {

    public static void main(String[] args){
        int arr[]={12,34,22,64,34,33,23,64,33};
        int i=0;
        int j=arr.length;
        while(i<j){
            i=quickSort(arr,i,i+1,j-1);

        }   
        for(i=0;i<arr.length;i++)
            System.out.print(arr[i]+" ");
    }

    public static int quickSort(int arr[],int pivot,int i,int j){

        if(i>j) {           
            swap(arr,pivot,j);
            return i;
        }

        while(i<arr.length&&arr[i]<=arr[pivot]) {
            i++;
        }

        while(j>=1&&arr[j]>=arr[pivot]) {           
            j--;
        }   
        if(i<j)
            swap(arr,i,j);

        return quickSort(arr,pivot,i,j);

    }   
    public static void swap(int[] arr,int i,int j) {
        int temp;
        temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

}

以上程序給出的輸出為：12 23 22 33 34 33 64 34 64

誰能告訴我怎樣才能得到我想要的結果呢？

Answer 1

問題是這不是真正的quicksort如何工作。 Quicksort是一種遞歸算法，只能從外部調用一次。 我們的想法是，在每次迭代中，您將數組分成兩半 - 左半部分包含小於樞軸的所有元素，右半部分包含大於/等於樞軸的所有元素。 然后你快速分配兩半，最后把樞軸放在中間。

如果您快速分配的一方長度少於3個元素，您可以只交換這兩個元素或保留它們，並完成該部分數組。

但是看起來你的代碼看起來並不是這樣 - 你從你的客戶端調用Quicksort 6次，並且在quicksort函數中你最多只進行一次交換。 所以這不是一個人可以通過告訴你移動交換或其他東西來查看你的代碼並進行調試的情況。 你需要重溫你的邏輯。

查看Wikipedia圖表，了解在一次迭代中應該發生的事情的可視化示例：

http://en.wikipedia.org/wiki/File:Partition_example.svg

Answer 2

在Apache Harmony和Apache Mahout中有快速排序的開源實現，可能在許多其他方面。 你可以閱讀它們。

Answer 3

你的循環不能正常工作。 請參閱解決快速排序問題的代碼

static void quickSort (int[] numbers, int low, int high)
{
    int i=low;
    int j=high;
    int temp;
    int middle=numbers[(low+high)/2];

    while (i<j) {

        while (numbers[i]<middle) {
            i++;
        }

        while (numbers[j]>middle) {
            j--;
        }

        if (i<=j) {
            temp=numbers[i];
            numbers[i]=numbers[j];
            numbers[j]=temp;
            i++;
            j--;
        }
    }

    if (low<j) {
        quickSort(numbers, low, j);
    }

    if (i<high) {
        quickSort(numbers, i, high);
    }
}

請參閱快速排序。

Answer 4

public static int partition(int[] a, int p, int r){

        int i=p,j=r,pivot=a[r];

        while(i<j){

            while(i<r && a[i] <= pivot){
                i++;
            }

            while(j>p && a[j]>pivot){ 
                j--;
            }

            if(i<j){
                swap(a, i, j);
            }           
        }   
        return j;
    }

    public static void quickSort(int[] a, int p, int r){
        if(p<r){
            int q=partition(a, p, r);

            if(p==q){
                quickSort(a, p+1, r);
            }else if(q==r){
                quickSort(a, p, r-1);
            }else {
                quickSort(a, p, q);
                quickSort(a, q+1, r);
            }

        }
    }

    public static void swap(int[] a, int p1, int p2){
        int temp=a[p1];
        a[p1]=a[p2];
        a[p2]=temp;
    }

Answer 5

這是一個快速排序算法

package drawFramePackage;
    import java.awt.geom.AffineTransform;
    import java.util.ArrayList;
    import java.util.ListIterator;
    import java.util.Random;
    public class QuicksortAlgorithm {
        ArrayList<AffineTransform> affs;
        ListIterator<AffineTransform> li;
        Integer count, count2;
        /**
         * @param args
         */
        public static void main(String[] args) {
            new QuicksortAlgorithm();
        }
        public QuicksortAlgorithm(){
            count = new Integer(0);
            count2 = new Integer(1);
            affs = new ArrayList<AffineTransform>();
            for (int i = 0; i <= 128; i++){
                affs.add(new AffineTransform(1, 0, 0, 1, new Random().nextInt(1024), 0));
            }
            affs = arrangeNumbers(affs);
            printNumbers();
        }
        public ArrayList<AffineTransform> arrangeNumbers(ArrayList<AffineTransform> list){
            while (list.size() > 1 && count != list.size() - 1){
                if (list.get(count2).getTranslateX() > list.get(count).getTranslateX()){
                    list.add(count, list.get(count2));
                    list.remove(count2 + 1);
                }
                if (count2 == list.size() - 1){
                    count++;
                    count2 = count + 1;
                }
                else{
                count2++;
                }
            }
            return list;
        }
        public void printNumbers(){
            li = affs.listIterator();
            while (li.hasNext()){
                System.out.println(li.next());
            }
        }
    }

也可以在nathan的計算機知識中描述[code] [/ code]``

Answer 6

請在此處找到用Java實現的快速排序算法的綜合工作代碼，

http://tech.bragboy.com/2010/01/quick-sort-in-java.html