#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <cassert>
//naive quicksort
template < class bidi_iterator, class predicate>
void quick_sort( const bidi_iterator first, const bidi_iterator last, const predicate& pred) {
using std:: swap ;
if ( first == last) //0
return ;
bidi_iterator next = std:: next ( first) ;
if ( next == last) // 1
return ;
if ( std:: next ( next) == last) { // 2
if ( pred( * next, * first) )
swap( * first, * next) ;
return ;
}
//3+
bidi_iterator mid = std:: partition ( next, last, std:: bind2nd ( pred, * first) ) ;
if ( mid! = next) { //1+ on left
bidi_iterator prev = std:: prev ( mid) ;
swap( * first, * prev) ;
if ( std:: next ( next) ! = mid) //2+ on left
quick_sort( first, prev, pred) ;
}
if ( mid! = last && mid! = std:: prev ( last) ) //2+ on right
quick_sort( mid, last, pred) ;
assert ( std:: is_sorted ( first, last, pred) ) ;
}
template < class bidi_iterator>
void quick_sort( const bidi_iterator first, const bidi_iterator last) {
typedef typename std:: iterator_traits < bidi_iterator> :: value_type value_type;
return quick_sort( first, last, std:: less < value_type> ( ) ) ;
}
//inplace quicksort
//This sort needs to work on a series of "chunks" in a certain format.
// Each chunk is: [(1)pivot][(?) data less than pivot, but greater than pivot of previous chunk]
// Given data: 17,16,8,6,18,12,14,13,8,6,5,19,22,12,16,20,7,0,10,6,15,18,19,6
// We chunk it: [17,16,8,6,6,12,14,13,8,6,5,15,6,12,16,10,7,0],[20,18,19,18,19],[22]
// Then we iterate over the list, one chunk at a time: [17,16,8,6,6,12,14,13,8,6,5,15,6,12,16,10,7,0]
// splitting each chunk into two subchunks: [16,7,8,6,6,12,14,13,8,6,5,15,6,12,0,10],[17,16,]
// A chunk that is 1 element (only the pivot, no data) is in the correct location.
template < class bidi_iterator, class predicate>
void inplace_sort( const bidi_iterator first, const bidi_iterator last, const predicate& pred) {
using std:: swap ;
using std:: distance ;
if ( first == last)
return ;
bidi_iterator beginchunk = first;
bidi_iterator endchunk = last;
bool cached_end = true ;
//Rearrange the origional data into "Chunks"
//Basically, just quicksort down the right side until we find the biggest element
do {
bidi_iterator mid = std:: partition ( std:: next ( beginchunk) , last, std:: bind2nd ( pred, * beginchunk) ) ;
if ( beginchunk == first) //cache first chunk size
endchunk = mid;
beginchunk = mid;
} while ( beginchunk ! = last) ;
beginchunk = first; //starting from the left
do {
//find first unsorted chunk (first consecutive unsorted elements)
bidi_iterator newpivot = std:: next ( beginchunk) ;
while ( newpivot! = last && pred( * beginchunk, * newpivot) ) {
beginchunk = newpivot;
++ newpivot;
cached_end = false ;
}
//if it's all sorted, we're done
if ( newpivot== last)
break ;
if ( cached_end == false ) {
//find the end of the chunk (first element greater than *beginchunk)
endchunk = std:: next ( newpivot) ;
int len = 2 ;
while ( endchunk! = last && pred( * endchunk, * beginchunk) ) {
++ len;
++ endchunk;
}
}
bidi_iterator mid = endchunk;
// if the chunk is two elements, just swap
if ( std:: next ( newpivot) == endchunk) {
swap( * beginchunk, * newpivot) ;
beginchunk = endchunk; //move to the next chunk
cached_end = false ;
} else {
//if more than two, partition into two seperate chunks
//first, parition on newpivot (the first element)
mid = std:: partition ( std:: next ( newpivot) , endchunk, std:: bind2nd ( pred, * newpivot) ) ;
//this means we have to move the pivots
//so the newpivot pivot begins the first subchunk
//and the beginchunk pivot begins the second subchunk
swap( * beginchunk, * newpivot) ;
bidi_iterator prev = std:: prev ( mid) ;
if ( newpivot ! = prev) {
swap( * newpivot, * prev) ;
//and cached the endchunk since we know it already
endchunk = mid;
cached_end = true ;
} else
cached_end = false ;
//and "repeat" which will do the left side
}
} while ( beginchunk ! = last) ;
assert ( std:: is_sorted ( first, last, pred) ) ;
return ;
}
template < class bidi_iterator>
void inplace_sort( bidi_iterator begin, bidi_iterator end) {
typedef typename std:: iterator_traits < bidi_iterator> :: value_type value_type;
return inplace_sort( begin, end, std:: less < value_type> ( ) ) ;
}
#include <cstdlib>
#include <ctime>
#include <vector>
template < typename T>
struct tracer : std:: less < T> {
static unsigned count;
bool operator( ) ( T x, T y) const {
++ count;
return std:: less < T> :: operator ( ) ( x, y) ;
}
} ;
template < typename T>
unsigned tracer< T> :: count = 0 ;
int main( ) {
unsigned test_size;
while ( std:: cin >> test_size) {
double stdsort_time= 0 ;
double inplacesort_time= 0 ;
srand ( ( unsigned ) time ( NULL ) ) ;
std:: vector < int > data( test_size) ;
for ( unsigned i= 0 ; i< data.size ( ) ; ++ i)
data[ i] = 10000 + rand ( ) ;
std:: vector < int > data2;
{
data2 = data;
std:: sort ( data2.begin ( ) , data2.end ( ) , tracer< int > ( ) ) ;
data2 = data;
clock_t begin = clock ( ) ;
std:: sort ( data2.begin ( ) , data2.end ( ) ) ;
clock_t end = clock ( ) ;
stdsort_time = double ( end- begin) / CLOCKS_PER_SEC ;
}
std:: cout << "comparisons: " << tracer< int > :: count << ' ' ;
std:: cout << "std::sort took " << stdsort_time << "s.\n " ;
tracer< int > :: count = 0 ;
{
data2 = data;
quick_sort( data2.begin ( ) , data2.end ( ) , tracer< int > ( ) ) ;
data2 = data;
clock_t begin = clock ( ) ;
quick_sort( data2.begin ( ) , data2.end ( ) ) ;
clock_t end = clock ( ) ;
stdsort_time = double ( end- begin) / CLOCKS_PER_SEC ;
}
std:: cout << "comparisons: " << tracer< int > :: count << ' ' ;
std:: cout << "quicksort took " << stdsort_time << "s.\n " ;
tracer< int > :: count = 0 ;
{
data2 = data;
inplace_sort( data2.begin ( ) , data2.end ( ) , tracer< int > ( ) ) ;
data2 = data;
clock_t begin = clock ( ) ;
inplace_sort( data2.begin ( ) , data2.end ( ) ) ;
clock_t end = clock ( ) ;
inplacesort_time = double ( end- begin) / CLOCKS_PER_SEC ;
}
std:: cout << "comparisons: " << tracer< int > :: count << ' ' ;
std:: cout << "inplace_sort took " << inplacesort_time << "s.\n " ;
}
return 0 ;
}
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <cassert>

//naive quicksort
template<class bidi_iterator, class predicate>
void quick_sort(const bidi_iterator first, const bidi_iterator last, const predicate& pred) {
	using std::swap;
	if (first == last) //0
		return;
	bidi_iterator next = std::next(first);
	if (next == last)  // 1
		return;
	if (std::next(next) == last) { // 2 
		if (pred(*next, *first))
			swap(*first, *next);
		return;
	}
	//3+
	bidi_iterator mid = std::partition(next, last, std::bind2nd(pred, *first));
	if (mid!=next) { //1+ on left
		bidi_iterator prev = std::prev(mid);
		swap(*first, *prev);
		if (std::next(next)!=mid) //2+ on left
			quick_sort(first, prev, pred);
	}
	if (mid!=last && mid!=std::prev(last)) //2+ on right
		quick_sort(mid, last, pred);
	assert(std::is_sorted(first, last, pred));
}
template<class bidi_iterator>
void quick_sort(const bidi_iterator first, const bidi_iterator last) {
	typedef typename std::iterator_traits<bidi_iterator>::value_type value_type;
	return quick_sort(first, last, std::less<value_type>());
}

//inplace quicksort
//This sort needs to work on a series of "chunks" in a certain format.
// Each chunk is: [(1)pivot][(?) data less than pivot, but greater than pivot of previous chunk]
//     Given data:  17,16,8,6,18,12,14,13,8,6,5,19,22,12,16,20,7,0,10,6,15,18,19,6
//     We chunk it: [17,16,8,6,6,12,14,13,8,6,5,15,6,12,16,10,7,0],[20,18,19,18,19],[22]
// Then we iterate over the list, one chunk at a time:  [17,16,8,6,6,12,14,13,8,6,5,15,6,12,16,10,7,0]
//    splitting each chunk into two subchunks: [16,7,8,6,6,12,14,13,8,6,5,15,6,12,0,10],[17,16,]
// A chunk that is 1 element (only the pivot, no data) is in the correct location.
template<class bidi_iterator, class predicate>
void inplace_sort(const bidi_iterator first, const bidi_iterator last, const predicate& pred) {
	using std::swap;
	using std::distance;
	if (first == last)
		return;
	bidi_iterator beginchunk = first;
	bidi_iterator endchunk = last;
	bool cached_end = true;
	//Rearrange the origional data into "Chunks"
	//Basically, just quicksort down the right side until we find the biggest element
	do {
		bidi_iterator mid = std::partition(std::next(beginchunk), last, std::bind2nd(pred, *beginchunk));
		if (beginchunk == first)  //cache first chunk size
			endchunk = mid;
		beginchunk = mid;
	} while(beginchunk != last);
	beginchunk = first; //starting from the left
	do {
		//find first unsorted chunk (first consecutive unsorted elements)
		bidi_iterator newpivot = std::next(beginchunk);
		while(newpivot!=last && pred(*beginchunk, *newpivot)) {
			beginchunk = newpivot; 
			++newpivot;
			cached_end = false;
		}
		//if it's all sorted, we're done
		if (newpivot==last) 
			break;
		if (cached_end == false) {
			//find the end of the chunk (first element greater than *beginchunk)
			endchunk = std::next(newpivot);
			int len = 2;
			while(endchunk!=last && pred(*endchunk, *beginchunk)) {
				++len;
				++endchunk;
			}
		}
		bidi_iterator mid =endchunk;
		// if the chunk is two elements, just swap
		if (std::next(newpivot) == endchunk) {
			swap(*beginchunk, *newpivot);	
			beginchunk = endchunk; //move to the next chunk
			cached_end = false;
		} else { 
			//if more than two, partition into two seperate chunks
			//first, parition on newpivot (the first element)
			mid = std::partition(std::next(newpivot), endchunk, std::bind2nd(pred, *newpivot));	
			//this means we have to move the pivots
			//so the newpivot pivot begins the first subchunk
			//and the beginchunk pivot begins the second subchunk
			swap(*beginchunk, *newpivot);
			bidi_iterator prev = std::prev(mid);
			if (newpivot != prev) {
				swap(*newpivot, *prev);
				//and cached the endchunk since we know it already
				endchunk = mid;
				cached_end = true;
			} else
				cached_end = false;
			//and "repeat" which will do the left side
		}
	} while(beginchunk != last);
	assert(std::is_sorted(first, last, pred));
	return;
}

template<class bidi_iterator>
void inplace_sort(bidi_iterator begin, bidi_iterator end) {
	typedef typename std::iterator_traits<bidi_iterator>::value_type value_type;
	return inplace_sort(begin, end, std::less<value_type>());
}

#include <cstdlib>
#include <ctime>
#include <vector>

template <typename T>
struct tracer : std::less<T> {
    static unsigned count;
 
    bool operator()(T x, T y) const {
        ++count;
        return std::less<T>::operator()(x, y);
    }
};
template <typename T>
unsigned tracer<T>::count = 0;
 
int main() {
        unsigned test_size;
        while(std::cin >> test_size) { 
			double stdsort_time=0;
			double inplacesort_time=0;
			srand((unsigned)time(NULL));
			std::vector<int> data(test_size);
			for(unsigned i=0; i<data.size(); ++i)
					data[i] = 10000+rand();
			std::vector<int> data2;
			{
					data2 = data;
					std::sort(data2.begin(), data2.end(), tracer<int>());
					data2 = data;
					clock_t begin = clock();
					std::sort(data2.begin(), data2.end());
					clock_t end = clock();
					stdsort_time = double(end-begin)/CLOCKS_PER_SEC;
			}
			std::cout << "comparisons: " << tracer<int>::count << ' ';
			std::cout << "std::sort    took " << stdsort_time << "s.\n";
			tracer<int>::count = 0;
			{
					data2 = data;
					quick_sort(data2.begin(), data2.end(), tracer<int>());
					data2 = data;
					clock_t begin = clock();
					quick_sort(data2.begin(), data2.end());
					clock_t end = clock();
					stdsort_time = double(end-begin)/CLOCKS_PER_SEC;
			}
			std::cout << "comparisons: " << tracer<int>::count << ' ';
			std::cout << "quicksort    took " << stdsort_time << "s.\n";
			tracer<int>::count = 0;
			{
					data2 = data;
					inplace_sort(data2.begin(), data2.end(), tracer<int>());
					data2 = data;
					clock_t begin = clock();
					inplace_sort(data2.begin(), data2.end());
					clock_t end = clock();
					inplacesort_time = double(end-begin)/CLOCKS_PER_SEC;
			}
			std::cout << "comparisons: " << tracer<int>::count << ' ';
			std::cout << "inplace_sort took " << inplacesort_time << "s.\n";
		}
        return 0;
}
 
