Beispiel #1
0
TEST_F(SortingTest, ShouldReturnAscendingSortedIfAlreadyDescending) {
	Sorting sorting;
	vector<int> sorted = sorting.selectionSort(desAges);
	
	ASSERT_EQ(10, sorted.front());
	ASSERT_EQ(30, sorted.back());
}
Beispiel #2
0
TEST_F(SortingTest, ShouldReturnTheSameOrderIfAlreadySorted) {
	Sorting sorting;
	vector<int> sorted = sorting.selectionSort(ascAges);
	
	ASSERT_EQ(sorted.front(), ascAges.front());
	ASSERT_EQ(sorted.back(), ascAges.back());
}
Beispiel #3
0
TEST_F(SortingTest, ShouldReturnSortedIfNotSorted) {
	Sorting sorting;
	vector<int> sorted = sorting.selectionSort(randAges);
	
	ASSERT_EQ(10, sorted.front());
	ASSERT_EQ(30, sorted.back());
}
Beispiel #4
0
TEST_F(SortingTest, ShouldReturnSortedForLargeGroupOfNumber) {
	Sorting sorting;
	vector<int> actual = sorting.selectionSort(lrgAges);
	
	for (int idx = 0; idx < lrgAges.size(); idx++) {
		ASSERT_EQ(sortedLrgAges.at(idx), actual.at(idx));
	}
}
Beispiel #5
0
/*
 * This function prints the Averages from the tests after running through all the tests.
 *
 * int max_size = maximum size that we want to test each sorting algorithm to
 * int min_size = minimum size that we want to test each sorting algorithm to
 * string theSort = string that contains tha name of the sorting algorithm we are testing.
 *
 * Worst-Case Time Complexity: Θ(n^2 + n^2 + n^2 + n^2) = Θ(n^2)
 */
void testing(int min_size, int max_size, string algorithm){
    // making sure I know what the size of each tests I'm doing
    const int& tests = 5;
    const int& test_size = 10;

    // making sure each size of the array is a set value
    const int& array_size = 10;

    // average cpu_time arrays for each data set
    float* increasing_array_averages = new float[array_size];
    float* decreasing_array_averages = new float[array_size];
    float* random_array_averages = new float[array_size];
    float* constant_array_averages = new float[array_size];

    std::cout << "\nIncreasing Array using " << algorithm << std::endl;

    // run 10 size instances (10000, 20000, 30000, etc.)
    for (int i = 0; i < test_size; i++){
        std::cout << max_size << " instances." << std::endl;

        // instantiate average value and sum value to zero on every new test.
        float average = 0.0;
        float sum = 0.0;

        // create new cpu_times array on every new test.
        float* cpu_times = new float[5];

        // run five tests
        for (int j = min_size; j < tests; j++){
            // set time to 0 before running the cpu times
            float time = 0.0;

            // instantiate new array for increasing ordered array.
            int* increasingArray = ag.generateIncreasingArray(max_size);
            if (algorithm == "insertionSort"){
                clock_t c_start = clock();
                s.insertionSort(increasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            else if (algorithm == "bubbleSort"){
                clock_t c_start = clock();
                s.bubbleSort(increasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }  
            else if (algorithm == "quickSort"){
                clock_t c_start = clock();
                s.quickSort(increasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            else if (algorithm == "mergeSort"){
                clock_t c_start = clock();
                s.mergeSort(increasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }    
            else {
                clock_t c_start = clock();
                s.selectionSort(increasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            //std::cout << "CPU Time (IncreasingArray): " << fixed << setprecision(3) << time << " ms." << std::endl;
            std::cout << fixed << setprecision(3) << time << " ms" << std::endl;

            // add cpu time to cpu_times array
            cpu_times[j] = time;

            // delete array at the end of each run to avoid memory leaks and faulty data
            delete[] increasingArray;
        }
        // add up the cpu_times values
        for (int j = 0; j < 5; j++){
            sum += cpu_times[j];
        }
        // find average value
        average = sum / 5.0;
        //std::cout << "Average time (" << max_size << " instances): " << average << "ms.\n" << std::endl;
        std::cout << fixed << setprecision(3) << average << " ms\n" << std::endl;

        // add average value to increasing_array_averages array per number of runs
        increasing_array_averages[i] = average;

        // once we pass our last instance (100000) break.
        if (max_size == 100000){
            break;
        }

        // go to the next instance (10000 to 20000)
        max_size += 10000;

        // delete cpu_times array to avoid memory leaks or faulty data
        delete[] cpu_times;
    }

    // start max_size back at 10000
    max_size = 10000;

    std::cout << "\nDecreasing Array using " << algorithm << std::endl;

    // run 10 size instances (10000, 20000, 30000, etc.)
    for (int i = min_size; i < test_size; i++){
        std::cout << max_size << " instances." << std::endl;
        // instantiate average value and sum value to zero on every new test.
        float average = 0.0;
        float sum = 0.0;

        // create new cpu_times array on every new test.
        float* cpu_times = new float[5];

        // run five tests
        for (int j = min_size; j < tests; j++){
            // set time to 0 before running the cpu times
            float time = 0.0;

            // instantiate new decreasing order array every run.
            int* decreasingArray = ag.generateDecreasingArray(max_size);

            if (algorithm == "insertionSort"){
                clock_t c_start = clock();
                s.insertionSort(decreasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            else if (algorithm == "bubbleSort"){
                clock_t c_start = clock();
                s.bubbleSort(decreasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }  
            else if (algorithm == "quickSort"){
                clock_t c_start = clock();
                s.quickSort(decreasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            else if (algorithm == "mergeSort"){
                clock_t c_start = clock();
                s.mergeSort(decreasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }    
            else {
                clock_t c_start = clock();
                s.selectionSort(decreasingArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }

            //std::cout << "CPU Time (DecreasingArray): " << fixed << setprecision(3) << time << " ms." << std::endl;
            std::cout << fixed << setprecision(3) << time << " ms" << std::endl;

            // add cpu time to cpu_times array
            cpu_times[j] = time;

            // delete array at the end of each run to avoid memory leaks and faulty data
            delete[] decreasingArray;
        }
        // add up the cpu_times values
        for (int j = 0; j < 5; j++){
            sum += cpu_times[j];
        }
        // find average value
        average = sum / 5.0;
        //std::cout << "Average time (" << max_size << " instances): " << fixed << setprecision(3) << average << "ms.\n" << std::endl;
        std::cout << fixed << setprecision(3) << average << " ms\n" << std::endl;
        // add average value to decreasing_array_averages array per number of runs
        decreasing_array_averages[i] = average;

        // once we pass our last instance (100000) break.
        if (max_size == 100000){
            break;
        }

        // go to the next instance (10000 to 20000)
        max_size += 10000;

        // delete cpu_times array to avoid memory leaks or faulty data
        delete[] cpu_times;
    }

    // start max_size back at 10000
    max_size = 10000;

    std::cout << "\nRandom Array using " << algorithm << std::endl;

    // run 10 size instances (10000, 20000, 30000, etc.)
    for (int i = min_size; i < test_size; i++){
        std::cout << max_size << " instances." << std::endl;
        // instantiate average value and sum value to zero on every new test.
        float average = 0.0;
        float sum = 0.0;

        // create new cpu_times array on every new test.
        float* cpu_times = new float[5];

        // run five tests
        for (int j = min_size; j < tests; j++){
            // set time to 0 before running the cpu times
            float time = 0.0;

            // instantiate new random order array every run.
            int* randomArray = ag.generateRandomArray(max_size);

            if (algorithm == "insertionSort"){
                clock_t c_start = clock();
                s.insertionSort(randomArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            else if (algorithm == "bubbleSort"){
                clock_t c_start = clock();
                s.bubbleSort(randomArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }  
            else if (algorithm == "quickSort"){
                clock_t c_start = clock();
                s.quickSort(randomArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            else if (algorithm == "mergeSort"){
                clock_t c_start = clock();
                s.mergeSort(randomArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }    
            else {
                clock_t c_start = clock();
                s.selectionSort(randomArray, max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }

            //std::cout << "CPU Time (RandomArray): " << fixed << setprecision(3) << time << " ms." << std::endl;
            std::cout << fixed << setprecision(3) << time << " ms" << std::endl;

            // add cpu time to cpu_times array
            cpu_times[j] = time;

            // delete array at the end of each run to avoid memory leaks and faulty data
            delete[] randomArray;
        }
        // add up the cpu_times values
        for (int j = 0; j < 5; j++){
            sum += cpu_times[j];
        }
        // find average value
        average = sum / 5.0;
        //std::cout << "Average time (" << max_size << " instances): " << fixed << setprecision(3) << average << "ms.\n" << std::endl;
        std::cout << fixed << setprecision(3) << average << " ms\n" << std::endl;

        // add average value to random_array_averages array per number of runs
        random_array_averages[i] = average;

        // once we pass our last instance (100000) break.
        if (max_size == 100000){
            break;
        }

        // go to the next instance (10000 to 20000)
        max_size += 10000;

        // delete cpu_times array to avoid memory leaks or faulty data
        delete[] cpu_times;
    }

    // start max_size back at 10000
    max_size = 10000;

    std::cout << "\nConstant Array using " << algorithm << std::endl;

    // run 10 size instances (10000, 20000, 30000, etc.)
    for (int i = 0; i < test_size; i++){
        std::cout << max_size << " instances." << std::endl;

        // instantiate average value and sum value to zero on every new test.
        float average = 0.0;
        float sum = 0.0;

        // create new cpu_times array on every new test.
        float* cpu_times = new float[5];

        // run five tests
        for (int j = 0; j < 5; j++){
            // set time to 0 before running the cpu times
            float time = 0.0;

            if (algorithm == "insertionSort"){
                clock_t c_start = clock();
                s.insertionSort(ag.generateConstArray("Awesome", max_size), max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            else if (algorithm == "bubbleSort"){
                clock_t c_start = clock();
                s.bubbleSort(ag.generateConstArray("Awesome", max_size), max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }  
            else if (algorithm == "quickSort"){
                clock_t c_start = clock();
                s.quickSort(ag.generateConstArray("Awesome", max_size), max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }
            else if (algorithm == "mergeSort"){
                clock_t c_start = clock();
                s.mergeSort(ag.generateConstArray("Awesome", max_size), max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }    
            else {
                clock_t c_start = clock();
                s.selectionSort(ag.generateConstArray("Awesome", max_size), max_size);
                clock_t c_end = clock();
                time = 1000 * (float(c_end) - float(c_start)) / CLOCKS_PER_SEC;
            }

            //std::cout << "CPU Time (ConstantArray): " << fixed << setprecision(3) << time << " ms." << std::endl;
            std::cout << fixed << setprecision(3) << time << " ms" << std::endl;

            // add cpu time to cpu_times array
            cpu_times[j] = time;

            // delete array at the end of each run to avoid memory leaks and faulty data
            delete[] ag.generateConstArray("Awesome", max_size);
        }
        // add up the cpu_times values
        for (int j = 0; j < 5; j++){
            sum += cpu_times[j];
        }
        // find average value
        average = sum / 5.0;
        //std::cout << "Average time (" << max_size << " instances): " << fixed << setprecision(3) << average << " ms.\n" << std::endl;
        std::cout << fixed << setprecision(3) << average << " ms\n" << std::endl;
        // add average value to constant_array_averages array per number of runs
        constant_array_averages[i] = average;

        // once we pass our last instance (100000) break.
        if (max_size == 100000){
            break;
        }

        // go to the next instance (10000 to 20000)
        max_size += 10000;

        // delete cpu_times array to avoid memory leaks or faulty data
        delete[] cpu_times;
    }

    // print averages of each array generated.
    printAverages(increasing_array_averages, decreasing_array_averages, random_array_averages, constant_array_averages, array_size, algorithm);

    // delete each array we used to hold specific (generated arrays) of averages from each test.
    delete[] constant_array_averages;
    delete[] random_array_averages;
    delete[] decreasing_array_averages;
    delete[] increasing_array_averages;
}