快速排序的以下实现是否相同？

Question

我在网站上遇到过这些快速排序的实现，一个是递归的，另一个是迭代的（使用辅助堆栈）。 Partition函数对于它们都是相同的。

Recursive quickSort

/* A[] --> Array to be sorted, l  --> Starting index, h  --> Ending index */
void quickSort(int A[], int l, int h)
{
    if (l < h)
    {       
       int p = partition(A, l, h); /* Partitioning index */
       quickSort(A, l, p - 1); 
       quickSort(A, p + 1, h);
    }
}

Iterative quickSort

* A[] --> Array to be sorted, l  --> Starting index, h  --> Ending index */
void quickSortIterative (int arr[], int l, int h)
{
    // Create an auxiliary stack
    int stack[ h - l + 1 ];

    // initialize top of stack
    int top = -1;

    // push initial values of l and h to stack
    stack[ ++top ] = l;
    stack[ ++top ] = h;

    // Keep popping from stack while is not empty
    while ( top >= 0 )
    {
        // Pop h and l
        h = stack[ top-- ];
        l = stack[ top-- ];

        // Set pivot element at its correct position in sorted array
       int p = partition( arr, l, h );

       // If there are elements on left side of pivot, then push left
       // side to stack
       if ( p-1 > l )
       {
           stack[ ++top ] = l;
           stack[ ++top ] = p - 1;
       }  

       // If there are elements on right side of pivot, then push right
       // side to stack
       if ( p+1 < h )
       {
           stack[ ++top ] = p + 1;
           stack[ ++top ] = h;
       }
   }
}

我在想的是，这些并不完全相同，因为第一部分（从l到p-1）递归地工作，然后在第二部分工作其他部分首先在第二部分（从p+1到h）开始工作？ 我这么认为是对的吗？