Question

我正在尝试使用Java实现快速排序。分区功能可以做它应该做的事情。也就是说，围绕数据块分割数组（我选择了元素作为数据透视）。但最终的输出不是按排序顺序排列的。我无法弄清楚错误。有人可以帮忙吗？

public class Quick_sort {


    public static int arr[] = {11, 2, 7, 1, 5, 4, 12, 65, 23};
    public static int temp = 0;

    public static void main(String args[]) {
        int p=0;
        int r=arr.length;

        quick_sort(p,r);        

        for(int i: arr)
            System.out.println(i);
    }


    public static int partition(int p, int r) {
        if(p < r) {
            int pivot=arr[p];
            int i=1;

            for(int j=1;j<r;j++) {
                if(arr[j]<pivot) {
                    temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                    i++;
                }
            }

            temp=arr[i-1];
            arr[i-1]=arr[p];
            arr[p]=temp;
            for(int m=0;m<r;m++) {
                if(arr[m]==pivot) {
                    temp=m;
                }
            }
        }
        return temp;    
    }

    public static void quick_sort(int p,int r) {
        if(p>=r) return;
        int index=partition(p,r);
        quick_sort(p,index-1);
        quick_sort(index+1,r-1);

    }
}

Answer 1

在你的最后一行

quick_sort(index+1,r-1);

跳过数组的最后一个元素。但是最后一个元素也应该被排序。尝试使用：

 quick_sort(index+1,r);

最好使分区方法中的变量i和j适应数组的当前处理部分。

Answer 2

所以我试着解决它。尝试使用（主要功能）：

int r=arr.length-1;

并将分区功能更改为：

public static int partition(int p, int r) {
    if(p < r) {
        int pivot=arr[p];
        int i= p ;

        for(int j=(p+1);j<=r;j++) {
            if(arr[j]<pivot) {
                temp=arr[j];
                arr[j]=arr[i + 1];
                arr[i + 1] = arr[i];
                arr[i] = temp;
                i++;
            }
        }
        temp = i;
    }
    return temp;    
}

以及快速排序方法：

quick_sort(p,index-1);
quick_sort(index+1,r);

你看到你的问题了吗？您的主要问题是不要将变量调整到您实际看到的较小部分。它适用于第一个分区循环，但不适用于以下内容，因为您使用了以前的变量。

Answer 3

嗯，这是即兴的快速排序代码

public class QuickSort 
{
   int partition(int arrNum[], int low, int high)
   {
      int pivot = arrNum[high]; 
      int a = (low - 1); // smaller element index
      for(int b = low; b < high; b++)
      {
         // condition to check current element is smaller than or equal to pivot
         if(arrNum[b] <= pivot)
         {
            a++;
            // swapping arrNum[a] and arrNum[b]
            int temp = arrNum[a];
            arrNum[a] = arrNum[b];
            arrNum[b] = temp;
         }
      }

      // swapping arrNum[a + 1] and arrNum[high]
      int temp = arrNum[a + 1];
      arrNum[a + 1] = arrNum[high];
      arrNum[high] = temp;

      return a + 1;
   }

   void sortNumber(int arr[], int low, int high)
   {
      if(low < high)
      { 
         int part = partition(arr, low, high);
         // Recursive function sort elements before partition and after partition
         sortNumber(arr, low, part - 1);
         sortNumber(arr, part + 1, high);
      }
   }

   // printing utility function
   static void printingArray(int arr[])
   {
      int num = arr.length;
      for(int a = 0; a < num; ++a)
         System.out.print(arr[a] + " ");
      System.out.println();
   }

   public static void main(String[] args) 
   {
      int arr[] = {33, 36, 63, 34, 45, 78};
      int n = arr.length;

      QuickSort qs = new QuickSort();
      qs.sortNumber(arr, 0, n - 1);

      System.out.println("Quicksort sorted array : ");
      printingArray(arr);
   }
}

有关快速排序算法的更多信息，请参阅this资源。

Answer 4

这是 QuickSort 实施的完整示例：

public class QuickSort {
    public static void main(String[] args) {
        int[] x = { 9, 2, 4, 7, 3, 7, 10 };
        System.out.println(Arrays.toString(x));

        int low = 0;
        int high = x.length - 1;

        quickSort(x, low, high);
        System.out.println(Arrays.toString(x));
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (arr == null || arr.length == 0)
            return;

        if (low >= high)
            return;

        // pick the pivot
        int middle = low + (high - low) / 2;
        int pivot = arr[middle];

        // make left < pivot and right > pivot
        int i = low, j = high;
        while (i <= j) {
            while (arr[i] < pivot) {
                i++;
            }

            while (arr[j] > pivot) {
                j--;
            }

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

        // recursively sort two sub parts
        if (low < j)
            quickSort(arr, low, j);

        if (high > i)
            quickSort(arr, i, high);
    }
}

您可以找到更多here。

Java错误输出中的快速排序imlpementation

4 个答案: