Java 为什么快速排序需要在“上”上递归；分类；分段？

对于alg/数据结构来说还是相当新的，但我们一直在尝试学习如何应用快速排序

我发现了以下实现：

让我困惑的部分是：

/* The main function that implements QuickSort() 
      arr[] --> Array to be sorted, 
      low  --> Starting index, 
      high  --> Ending index */
    void sort(int arr[], int low, int high) 
    { 
        if (low < high) 
        { 
        /* pi is partitioning index, arr[pi] is  
          now at right place */
        int pi = partition(arr, low, high); 

        // Recursively sort elements before 
        // partition and after partition 
        sort(arr, low, pi-1); 
        sort(arr, pi+1, high); 
    } 
} 

/*实现快速排序（）的主要函数
arr[]-->要排序的数组，
低-->起始索引，
高-->结束索引*/
无效排序（整数arr[]，整数低位，整数高位）
{ 
如果（低<高）
{ 
/*pi是分区索引，arr[pi]是
现在在正确的地方*/
int pi=分区（arr、低、高）；
//对元素进行递归排序
//分区和分区后
排序（arr、低、pi-1）；
排序（arr、pi+1、高）；
} 
} 

---

在我看来，我们不应该在排序（arr，low，pi-1）部分递归，因为算法应该已经对该部分进行了排序…

在您的快速排序实现中，我在一些地方进行了注释，以更清楚地说明快速排序背后的思想。在您使用

partition

函数计算变量

pi

的代码中，索引

pi

之前的所有元素都小于

arr[pi]

，但不能保证它们是按顺序排序的。此外，索引

pi

之后的所有元素都大于

arr[pi]

但不能保证它们按顺序排序。我已在下面的代码中注释掉：

int partition (arr[], low, high)
{
   // pivot (Element to be placed at right position)
   pivot = arr[high];  
   i = (low - 1)  // Index of smaller element
   for (j = low; j <= high- 1; j++)
   {
    // If current element is smaller than or equal to pivot
    /* But, it does not guaranteed that smaller elements will come in sorted fashion*/
    if (arr[j] <= pivot)
    {
        i++;    // increment index of smaller element
        swap arr[i] and arr[j]
     }
   }
   swap arr[i + 1] and arr[high])
   return (i + 1)
 }

/* The main function that implements QuickSort() 
  arr[] --> Array to be sorted, 
  low  --> Starting index, 
  high  --> Ending index */
 void sort(int arr[], int low, int high) 
 { 
    if (low < high) 
    { 
    /* pi is partitioning index, arr[pi] is  
      now at right place */
     int pi = partition(arr, low, high); 
     /*Here, all the elements before index pi are less than arr[pi] but 
       not guaranteed that they are in sorted order.
       Also, all the elements after index pi are greater than arr[pi] but 
       not guaranteed to be in sorted order.
     */
     // Recursively sort elements before 
     // partition and after partition 
     sort(arr, low, pi-1); 
     sort(arr, pi+1, high); 
  } 
} 

int分区（arr[]，低，高）
{
//枢轴（要放置在正确位置的图元）
枢轴=arr[高]；
i=（低-1）//较小元素的索引
对于（j=低；j起动指数，
高-->结束索引*/
无效排序（整数arr[]，整数低位，整数高位）
{ 
如果（低<高）
{ 
/*pi是分区索引，arr[pi]是
现在在正确的地方*/
int pi=分区（arr、低、高）；
/*这里，索引pi之前的所有元素都小于arr[pi]，但是
不保证它们是按顺序排列的。
此外，索引pi之后的所有元素都大于arr[pi]，但
不保证按顺序排序。
*/
//对元素进行递归排序
//分区和分区后
排序（arr、低、pi-1）；
排序（arr、pi+1、高）；
} 
} 

您知道分区的功能吗？分区不会对任何一方进行排序…它只保证左侧的所有内容都小于分区，右侧的所有内容都大于分区。是什么让您认为该部分已经排序了？