Question

data strutures in c++ please

implement the QuickSort algorithm as a C++ function. Use it to sort a large number of integers, say at least 100000. Do a timing test on the sort. Then use the build-in sort() function in to sort the same data and time this sort. Which sort is better? Do some research to see if you can determine what algorithm the built-in sort() function uses and describe this sort if it is different than QuickSort.

Answer 1

from c++ 11 onwards there is an chrono library which is used to measure the time of running time of functions

#include <bits/stdc++.h>
#include<chrono>
#define SIZE 100000
using namespace std;
using namespace std::chrono;

int part(int A[],int start,int end)
{
   int i=start+1;
   int piv=A[start];//make the first element as pivot element.
   /*rearrange the array by putting elements which are less than pivot
on one side and which are greater that on other. */
   for(int j=start+1;j<=end;j++)
   {
       if(A[j]<piv)
       swap(A[i],A[j]),i++;
   }
   swap(A[start],A[i-1]);//put the pivot element in its proper place.
   return i-1;//return postion of pivot
}
void quick_sort(int A[],int start,int end)
{
   if(start<end)
   {
       //stores the position of pivot element
       int piv=part(A,start,end);
       quick_sort(A,start,piv-1);
       quick_sort(A,piv+1,end);
   }
}
void in_built_sort(int A[],int n)
{
   sort(A,A+n);
}
int main() {
   //make a array of size 100000
   int a[SIZE],b[SIZE];
   //fill the arrays with random values
   for(int i=0;i<SIZE;i++)
   {
       a[i]=rand();
       b[i]=rand();
   }
   //hih_resolution is used to calculate the running time of a function
   high_resolution_clock::time_point t1 = high_resolution_clock::now();
   quick_sort(a,0,SIZE-1);
   high_resolution_clock::time_point t2 = high_resolution_clock::now();
   //duration is running time of quick sort in ms
   auto duration = duration_cast<microseconds>( t2 - t1 ).count();
   cout<<"duration of quick sort is "<<duration<<"ms"<<endl;
   //measure the running time of inbuilt sort function
   high_resolution_clock::time_point t3 = high_resolution_clock::now();
   in_built_sort(b,SIZE);
   high_resolution_clock::time_point t4 = high_resolution_clock::now();
   duration = duration_cast<microseconds>( t4 - t3 ).count();
   cout<<"duration of inbuilt sort is "<<duration<<"ms"<<endl;
   return 0;
}

the running time of standard sort function is better

standard sort function uses intro -sort which is hybrid sort of quick sort,heap sort and insertion sort