PHP recursive Efficiency Analysis

In addition, it is 3 times less efficient. Therefore, you must be careful with recursion in PHP.
I recently wrote a fast Sorting Algorithm and found that the recursive efficiency in PHP cannot be one-size-fits-all. It may be different on different servers.
Copy codeThe Code is as follows:
Function qsort (& $ arr)
{
_ Quick_sort ($ arr, 0, count ($ arr)-1 );
}

/**
* Uses recursive algorithms for fast sorting.
*
* @ Param array $ array to be sorted by arr
* @ Param int $ low: lowest sort sub-segment
* @ Param int $ highest sorting Field
*/
Function _ quick_sort (& $ arr, $ low, $ high)
{
$ Low_data = $ arr [$ low];
$ Prev_low = $ low;
$ Prev_high = $ high;
While ($ low <$ high)
{
While ($ arr [$ high] >=$ low_data & $ low <$ high ){
$ High --;
}
If ($ low <$ high ){
$ Arr [$ low] = $ arr [$ high];
$ Low ++;
}
While ($ arr [$ low] <= $ low_data & $ low <$ high ){
$ Low ++;
}
If ($ low <$ high ){
$ Arr [$ high] = $ arr [$ low];
$ High --;
}
}
$ Arr [$ low] = $ low_data;
If ($ prev_low <$ low ){
_ Quick_sort ($ arr, $ prev_low, $ low );
}
If ($ low + 1 <$ prev_high ){
_ Quick_sort ($ arr, $ low + 1, $ prev_high );
}
}

Function quick_sort (& $ arr)
{
$ Stack = array ();
Array_push ($ stack, 0 );
Array_push ($ stack, count ($ arr)-1 );
While (! Empty ($ stack )){
$ High = array_pop ($ stack );
$ Low = array_pop ($ stack );
$ Low_data = $ arr [$ low];
$ Prev_low = $ low;
$ Prev_high = $ high;
While ($ low <$ high)
{
While ($ arr [$ high] >=$ low_data & $ low <$ high ){
$ High --;
}
If ($ low <$ high ){
$ Arr [$ low] = $ arr [$ high];
$ Low ++;
}
While ($ arr [$ low] <= $ low_data & $ low <$ high ){
$ Low ++;
}
If ($ low <$ high ){
$ Arr [$ high] = $ arr [$ low];
$ High --;
}
}
$ Arr [$ low] = $ low_data;
If ($ prev_low <$ low ){
Array_push ($ stack, $ prev_low );
Array_push ($ stack, $ low );
}
If ($ low + 1 <$ prev_high ){
Array_push ($ stack, $ low + 1 );
Array_push ($ stack, $ prev_high );
}
}
}

The code for testing speed is as follows:
Copy codeThe Code is as follows:
Function qsort_test1 ()
{
$ Arr = range (1, 1000 );
Shuffle ($ arr );
$ Arr2 = $ arr;
$ T1 = microtime (true );
Quick_sort ($ arr2 );
$ T2 = microtime (true)-$ t1;
Echo "cost of non-recursive calls:". $ t2. "\ n ";
$ Arr1 = $ arr;
$ T1 = microtime (true );
Qsort ($ arr1 );
$ T2 = microtime (true)-$ t1;
Echo "recursive call cost:". $ t2. "\ n ";
}

On my IIS server (CGI) mode, my test result is:
Cost of non-recursive calls: 0.036401009559631
Recursive call cost: 0.053439617156982
On My Apache server, my test result is:
Cost of non-recursive calls: 0.022789001464844
Recursive call cost: 0.014809131622314
The results are the opposite, while the PHP version is the same.
It seems that the efficiency of recursion needs to be analyzed in detail.