Quicksort without tail recursion - c++

Question

I have written the following randomized quicksort code using tail recursion. I wanted to see the effect of not using tail recursion and wanted to see how the time of execution and run time are affected. How can we remove tail recursion from the below randomized quicksort code?
#include<iostream>
#include<cstdlib>
using namespace std;
int partition(int low,int high,int a[])
{
int index=(rand()%(high-low))+low;
//cout<<endl<<index<<"----"<<endl;
int temp1=a[index];
a[index]=a[low];
a[low]=temp1;
int left,right,pivot_item=a[low];
left=low;
right=high;
while(left<right)
{
while(a[left]<=pivot_item)
left++;
while(a[right]>pivot_item)
right--;
if(left<right)
{
int temp=a[right];
a[right]=a[left];
a[left]=temp;
}
}
a[low]=a[right];
a[right]=pivot_item;
return right;
}
void quicksort(int low,int high,int a[])
{
int pivot;
if(low<high)
{
pivot=partition(low,high,a);
quicksort(low,pivot-1,a);
quicksort(pivot+1,high,a);
}
}
int main()
{
srand(time(NULL));
int n;
n=50;
int a[n];
int i;
for(i=0;i<n;i++)
a[i]=(rand()%(1000-1));
quicksort(0,n-1,a);
cout<<endl;
for(i=0;i<n;i++)
cout<<a[i]<<endl;
return 0;
}
EDIT:
Is there any way to altogether remove the second recursive call in the quicksort function. This would mean removing tail recursion and would also significantly affect the time.

Answer 1

A simple way to remove tail recursion is to do something else in the function after making the recursive call. Below I've changed the function to return a value instead of void, and added a return statement to rturn something after the recursive call is finished. This should have minimal performance impact.
int quicksort(int low,int high,int a[])
{
int pivot;
if(low<high)
{
pivot=partition(low,high,a);
quicksort(low,pivot-1,a);
quicksort(pivot+1,high,a);
}
return 0;
}

Answer 2

Compilers typically have an option to enable and disable particular optimizations.
In case of g++ and related compilers, you can enable and disable tail call optimization using -foptimize-sibling-calls and -fno-optimize-sibling-calls options. If you use another compiler, see the manual.
I would recommend using these to compare the effect of tail recursion, because it allows you to use the same algorithm.
Quicksort is naturally tail recursive, so it's not simple to make non-tail-recurive. One one hand, it's easy: simply do something after the recursion call. Voilà, the algorithm is now no longer tail recursive. But, what you do after the recursion is important. It must have a side-effect, or else it can be optimized away. But then it would affect the performance and you're no longer measuring only the effect of the tail call optimization.
Here is an idea. Implement two identical functions that call each other instead if themselves in the tail call:
void quicksort1(int low,int high,int a[])
{
int pivot;
if(low<high)
{
pivot=partition(low,high,a);
quicksort1(low,pivot-1,a);
quicksort2(pivot+1,high,a);
}
}
void quicksort2(int low,int high,int a[])
{
int pivot;
if(low<high)
{
pivot=partition(low,high,a);
quicksort2(low,pivot-1,a);
quicksort1(pivot+1,high,a);
}
}
It's still possible to do tail call optimization on mutually recursive functions, so I won't guarantee that a smart compiler won't figure out what's going on. But the optimization will be harder to implement, so some compilers might not attempt to do it. Check the assembly if you want to be sure. Also, this may have some effect on instruction cache, so it may have an effect on performance other than just disabling the tail call optimization.