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是一种递归算法，只能从外部调用一次。我们的想法是，在每次迭代中，您将数组分成两半 - 左半部分包含小于枢轴的所有元素，右半部分包含大于/等于枢轴的所有元素。然后你快速分配两半，最后把枢轴放在中间。

如果您要快速分配的一方长度少于3个元素，您可以只交换这两个元素或保留它们，并完成该部分数组。

但是看起来你的代码看起来并不是这样 - 你从你的客户端调用Quicksort 6次，并且在quicksort函数中你最多只进行一次交换。所以这不是一个人可以通过告诉你移动交换或其他东西来查看你的代码并进行调试的情况。你需要重温你的逻辑。

查看Wikipedia图表，了解在一次迭代中应该发生什么的可视化示例：

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

Answer 2

在Apache Harmony和Apache Mahout中有快速排序的开源实现，可能在许多其他方面。你可以阅读它们。

Answer 3

请在此处找到用Java实现的快速排序算法的全面工作代码，

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

Answer 4

您的循环无法正常工作。请参阅解决Quick Sort

问题的代码

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);
    }
}

参考Quick sort.

Answer 5

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 6

这是一个快速排序算法

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's computer knowledge的说明中找到说明 [码] [/码] ``

Java中的Quicksort算法程序

6 个答案: