Java 快速排序分区算法

我正试图从Cormen算法教科书中编写快速排序算法。下面是我的代码

class Quicksort
{
    public void qSort(int[] a, int p, int r)
    {
        if(p<r)
        {
            int q = Partition(a, p,r);
            qSort(a, p, q-1);
            qSort(a, q+1, r);
        }
     }

     private int Partition(int[] a, int p, int r)
     {
         int x = a[r];

         int i = p-1;
         int temp=0;

         for(int j=p; j<r-1; j++)
         {
             if(a[j]<=x)
             {
                 i++;
                 temp = a[i];
                 a[i] = a[j];
                 a[j] = temp;
             }
         }

         temp = a[i+1];
         a[i+1] = a[r];
         a[r] = temp;
         return (i+1);
     }
}

public class QuickSortTest
{
     public static void main(String[] args)
     {
         Quicksort qsort = new Quicksort();
         int[] array = {5, 4, 7, 2, 1, 9, 3, 6, 10, 8};

         System.out.print("Original  Array : ");
         for(int i=0; i<array.length;i++)
         {
             System.out.print(array[i] + " ");
         }

         int length = array.length;

         qsort.qSort(array, 0, length-1);

         System.out.print("Sorted  Array : ");
         for(int i=0; i<array.length;i++)
         {
             System.out.print(array[i] + " ");
         }
     }
}

---

谁能解释一下是怎么回事吗。我已经完全按照“算法简介”一书中给出的方式实现了这段代码。谢谢。

如果您想了解如何实现快速排序，可以尝试检查jdk中array.sort（*）的实际源代码，jdk是快速排序的修改版本。（如果您的jdk安装中还没有src.zip，请下载）。

不，您没有直接复制它：）我在这里有它

for(int j=p; j<r-1; j++)

其中包括

r-1

。请记住，这本书中的数组是从1开始的，而不是从0开始的。所以一般来说，书中的算法应该非常小心地“复制”，或者使用从1开始的数组

编辑：有关注释算法的信息

---

书中的算法以最后一个元素为轴心。因此，对于已经排序的数组，它将成为一个糟糕的算法。它将以O（n^2）结束，因此任何人都不应该在生产中使用此算法（除非您知道自己在做什么以及输入是什么），因为数组往往会进行某种排序。Java的内置算法更聪明，您可以在Javadoc中阅读，它提供了一个Java实现。它也基于相同的算法，并负责数组中的重复元素

    public void sort( int[] inputArray, int lo, int high){
          int pivotIndex = partition(inputArray,lo,high);
         System. out .println("Got PivotIndex as " + pivotIndex);
          if (lo < pivotIndex -1)
                sort(inputArray,lo,pivotIndex - 1);
          if (pivotIndex+1 < high)
                sort(inputArray,pivotIndex+1,high);
          return ;
    }

    private int partition( int[] inputArray, int leftPtr,int rightPtr)
   {
         printArray(inputArray);
          int pivot = inputArray[leftPtr];
          while (leftPtr<rightPtr){
                 while (inputArray[leftPtr]<pivot)
                       leftPtr++;
                 while (inputArray[rightPtr]>pivot)
                       rightPtr--;
                 if (leftPtr<rightPtr)
                {
                       exchange(inputArray,leftPtr,rightPtr);

                          //Cases which have repeated numbers...
                        if (inputArray[leftPtr] == inputArray[rightPtr])
                             leftPtr++;
                }
         }
          return leftPtr;//return any one
   }

public void排序（int[]输入阵列、int-lo、int-high）{
int pivotIndex=分区（输入阵列、低、高）；
System.out.println（“获取数据透视索引为”+数据透视索引）；
如果（lo<数据透视索引-1）
排序（输入阵列、lo、数据透视索引-1）；
if（数据透视指数+1<高）
排序（输入阵列，数据透视索引+1，高）；
返回；
}
私有int分区（int[]输入阵列、int leftPtr、int righptr）
{
打印阵列（输入阵列）；
int pivot=inputArray[leftPtr]；
while（LeftpThanks用于回答LasseSpheholt。我的书中包含了j=p到r-1的伪代码。这是唯一的问题。@Race:有一个非常类似的算法，尽管那篇文章中描述的pivotIndex和left似乎结合在你/教科书的算法中。@Merlyn请参阅编辑：）它使用最右边的元素，因此不需要额外的透视索引。此实现需要注意的另一件事是输入边界。例如，如答案中突出显示的，由于透视选择几乎未对数据进行排序。因此，如果您要求此实现在数字0之间对1000000进行排序
for(int j=p; j<r; j++)

for(int j=p; j <= r-1; j++)

for j = p to r - 1

    public void sort( int[] inputArray, int lo, int high){
          int pivotIndex = partition(inputArray,lo,high);
         System. out .println("Got PivotIndex as " + pivotIndex);
          if (lo < pivotIndex -1)
                sort(inputArray,lo,pivotIndex - 1);
          if (pivotIndex+1 < high)
                sort(inputArray,pivotIndex+1,high);
          return ;
    }

    private int partition( int[] inputArray, int leftPtr,int rightPtr)
   {
         printArray(inputArray);
          int pivot = inputArray[leftPtr];
          while (leftPtr<rightPtr){
                 while (inputArray[leftPtr]<pivot)
                       leftPtr++;
                 while (inputArray[rightPtr]>pivot)
                       rightPtr--;
                 if (leftPtr<rightPtr)
                {
                       exchange(inputArray,leftPtr,rightPtr);

                          //Cases which have repeated numbers...
                        if (inputArray[leftPtr] == inputArray[rightPtr])
                             leftPtr++;
                }
         }
          return leftPtr;//return any one
   }