#include <iostream.h>
#include <stdlib.h>
#include <time.h>
#include <vector>
#include <iomanip>
#include <algorithm>
#include <cstdlib>

using namespace std;

class quicksort
{
public:
	quicksort( unsigned int vectorSize );	//constructor with arguments
	~quicksort();				//destructor
	void qsort(T data[], int first, int last);		//function to bubble sort the values.
	void put();				//function to print the values.
	

	
private:
	std::vector<int> data;		//vector testData
	
   
};

#include <iostream.h>
#include <stdlib.h>
#include <time.h>
#include "bub1.h"  // Header file
#include <vector>
#include <iomanip>
#include <algorithm>
#include <cstdlib>
using namespace std;

quicksort::quicksort()			 //constructor     
{
int size;
	 

	 cout<<"Enter an array of 10, 100, 1000 to be randomly sorted"<< endl;
         cin >> size;		//get the size required by the user.
     
	 (srand( (unsigned)time( NULL ) )); //seed the rand function
      
	 data.resize( size );  //resize the sort

         for (int i=0;  i < size; i++)
         {
            data[i] = rand();     // pointers of the function srand
         }
}

quicksort::~quicksort()					 // Destructor
{
    data.clear();                //Clear the vector contents

}
template <class T>
void quicksort::qsort(T data[], int first, int last)
{
	int lower = first+1, upper = last;					
int count = 0;
   swap(data[first], data[(first+last)/2]);
   T bound = data[first];
   while (lower<=upper)
   {
	   while (data[lower] < bound)
		   lower++;
	   while (bound < data[upper])
		   upper--;
	   if (lower < upper)
		   swap(data[lower++], data[upper--]);
	   else lower++;
   }
   swap(data[upper], data[first]);
   if (first < upper-1)
	   quicksort (data,first,upper-1);
   if (upper+1 < last)
	   quicksort (data,upper+1,last);
}
quicksort(T data[], int n);
{
	if (n<2)
		return;
	for (int i = 1, max = 0; i < n; i++)
		if (data[max] < data[i])
			max = i;
		swap(data[n-1], data[max]);
		quicksort(data, 0, n-2);

            if ( data[j] > data[j+1] ) 
			{
				temp = data[j];			//sort the data in Data vector itself. 
				data[j] = data[j+1];
				data[j+1] = temp;
				count++;
			 }	
			
			cout<< "\n" << "here are the number of swaps done" << endl;
	cout << count << endl;
}




void quicksort::put()                            //prints the contents of arr
{
	
	cout<< "\n" << "Here are your numbers"<< endl;  
    
	for (int i =0; i < data.size(); i++)
        cout<< "\n" << data[i] << endl;        //print the output.
	
	
}

#include <iostream.h>
#include <stdlib.h>
#include <time.h>
#include "bub1.h"  // Header file

int main()
{

    sort a;                //create object a. this automatically calls the default constructor
    
    cout<<"Before sorting"<<endl;

    a.put();                //prints the value in arr

    a.qsort();        //sort arr

    cout<<"After sorting"<<endl;

    a.put();                //prints the value of arr

	cin.get();              //pause the program for a while    

   

    return 0;

}

public:
    quicksort( );                                 // default constructor
    quicksort( unsigned int vectorSize );    //constructor with arguments
    ~quicksort();    

        template <class T>
	void qsort(T data[], int first, int last);		//function to bubble sort the values.

//define data, first and last here...
    a.qsort(data, first, last);        //sort data

void quick_sort()
{
    quick_sort(data, 0, data.size());
}

quicksort(T data[], int n);
{
    if (n<2)
        return;
    for (int i = 1, max = 0; i < n; i++)
        if (data[max] < data[i])
            max = i;
        swap(data[n-1], data[max]);
        quicksort(data, 0, n-2);

            if ( data[j] > data[j+1] ) 
            {
                temp = data[j];            //sort the data in Data vector itself. 
                data[j] = data[j+1];
                data[j+1] = temp;
                count++;
             }    
            
            cout<< "\n" << "here are the number of swaps done" << endl;
    cout << count << endl;
}