Example #1
0
int main(int argc, char** argv) 
{
	system("PAUSE");
	
	std::list<int> a_list, b_list;
	std::srand(std::time(0)); // use current time as seed for random generator
    	
	for (int i = 0; i < 5000000; ++i)
	{
		int value = std::rand();
		a_list.push_back(value);
		b_list.push_back(value);
	}
	
	//std::list<int> b_list(a_list);
	std::cout << "b_list.size() = " << b_list.size() << std::endl;
	
    // record start time
    auto start = std::chrono::system_clock::now();
    // do some work
    a_list = parallel_quick_sort(a_list);
    
    // record end time
    auto end = std::chrono::system_clock::now();
    std::chrono::duration<double> diff = end-start;
    std::cout << "Time to sort a list of " 
              << a_list.size() << " ints : " << diff.count() << " s\n";
              
    std::cout << "Thread counter is " << thread_counter << std::endl;
	
		
    // record start time
    auto startb = std::chrono::system_clock::now();

    // do some work
    b_list = sequential_quick_sort(b_list);
    
    // record end time
    auto endb = std::chrono::system_clock::now();
    std::chrono::duration<double> diffb = endb-startb;
    std::cout << "Time to sort b list of " 
              << b_list.size() << " ints : " << diffb.count() << " s\n";
              
    auto itrA = a_list.begin();
    auto itrB = b_list.begin();
    for (int i = 0; i < 10; i++)
    {
    	std::cout << *(itrA++) << " ";
	}
	std:: cout << std::endl;

    for (int i = 0; i < 10; i++)
    {
    	std::cout << *(itrB++) << " ";
	}
	
	return 0;
}
int main()
{
    std::list<int> list1 = {4, 2, 1, 5, 8, 9, 7};
    std::list<int> sorted1 = sequential_quick_sort(list1);
    std::list<int> sorted2 = parallel_quick_sort(list1);
    std::cout << "sorted1: " << sorted1 << std::endl;
    std::cout << "sorted2: " << sorted2 << std::endl;
    return 0;
}
Example #3
0
std::list<T> sequential_quick_sort(std::list<T> input) {
    if (input.empty())
        return input;

    std::list<T> result;
    result.splice(result.begin(), input, input.begin());
    const T& pivot = *result.begin();

    auto pts = std::partition(input.begin(), input.end(),
                              [pivot](const T& x) { return x < pivot; });
    std::list<T> lower_part;
    lower_part.splice(lower_part.end(), input, input.begin(), pts);
    auto new_lower = sequential_quick_sort(std::move(lower_part)),
         new_higher = sequential_quick_sort(std::move(input));
    result.splice(result.end(), new_higher);
    result.splice(result.begin(), new_lower);
    return result;
}