QuestionSORT SET: n = 50, all sorts, by weight Bubble sort 5

QuestionSORT SET: n = 50, all sorts, by weight Bubble sort 50 monsters by…SORT SET: n = 50, all sorts, by weightBubble sort 50 monsters by weight…Sort complete with:       1225 comparisons          0 block copies          0 total copies        539 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Selection sort 50 monsters by weight…Sort complete with:       1274 comparisons          0 block copies          0 total copies         45 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Insertion sort 50 monsters by weight…Sort complete with:        732 comparisons         46 block copies       1311 total copies          0 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Quick sort 50 monsters by weight…Sort complete with:        273 comparisons          0 block copies          0 total copies        166 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Merge sort 50 monsters…Sort complete with:        226 comparisons         98 block copies        572 total copies          0 swaps         49 allocations       0.00s CPU time usedThe list is sorted.Merge-insertion sort 50 monsters…Sort complete with:        429 comparisons         45 block copies        771 total copies          0 swaps          1 allocations       0.00s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 50, all sorts, by nameBubble sort 50 monsters by name…Sort complete with:       1225 comparisons          0 block copies          0 total copies        589 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Selection sort 50 monsters by name…Sort complete with:       1274 comparisons          0 block copies          0 total copies         45 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Insertion sort 50 monsters by name…Sort complete with:        680 comparisons         44 block copies       1188 total copies          0 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Quick sort 50 monsters by name…Sort complete with:        236 comparisons          0 block copies          0 total copies        149 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Merge sort 50 monsters…Sort complete with:        217 comparisons         98 block copies        572 total copies          0 swaps         49 allocations       0.00s CPU time usedThe list is sorted.Merge-insertion sort 50 monsters…Sort complete with:        404 comparisons         44 block copies        733 total copies          0 swaps          1 allocations       0.00s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 500, all sorts, by weightBubble sort 500 monsters by weight…Sort complete with:     124750 comparisons          0 block copies          0 total copies      62545 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Selection sort 500 monsters by weight…Sort complete with:     125249 comparisons          0 block copies          0 total copies        493 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Insertion sort 500 monsters by weight…Sort complete with:      62699 comparisons        494 block copies     125537 total copies          0 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Quick sort 500 monsters by weight…Sort complete with:       4714 comparisons          0 block copies          0 total copies       2889 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Merge sort 500 monsters…Sort complete with:       3856 comparisons        998 block copies       8976 total copies          0 swaps        499 allocations       0.00s CPU time usedThe list is sorted.Merge-insertion sort 500 monsters…Sort complete with:       4703 comparisons        459 block copies       9119 total copies          0 swaps         31 allocations       0.00s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 500, all sorts, by nameBubble sort 500 monsters by name…Sort complete with:     124750 comparisons          0 block copies          0 total copies      59828 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Selection sort 500 monsters by name…Sort complete with:     125249 comparisons          0 block copies          0 total copies        495 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Insertion sort 500 monsters by name…Sort complete with:      65413 comparisons        491 block copies     124679 total copies          0 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Quick sort 500 monsters by name…Sort complete with:       4887 comparisons          0 block copies          0 total copies       2831 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Merge sort 500 monsters…Sort complete with:       3849 comparisons        998 block copies       8976 total copies          0 swaps        499 allocations       0.00s CPU time usedThe list is sorted.Merge-insertion sort 500 monsters…Sort complete with:       4717 comparisons        456 block copies       9057 total copies          0 swaps         31 allocations       0.00s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 5000, all sorts, by weightBubble sort 5000 monsters by weight…Sort complete with:   12497500 comparisons          0 block copies          0 total copies    6273432 swaps          0 allocations       0.17s CPU time usedThe list is sorted.Selection sort 5000 monsters by weight…Sort complete with:   12502499 comparisons          0 block copies          0 total copies       4991 swaps          0 allocations       0.06s CPU time usedThe list is sorted.Insertion sort 5000 monsters by weight…Sort complete with:    6229059 comparisons       4991 block copies   12499544 total copies          0 swaps          0 allocations       0.04s CPU time usedThe list is sorted.Quick sort 5000 monsters by weight…Sort complete with:      69387 comparisons          0 block copies          0 total copies      37359 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Merge sort 5000 monsters…Sort complete with:      55176 comparisons       9998 block copies     123616 total copies          0 swaps       4999 allocations       0.00s CPU time usedThe list is sorted.Merge-insertion sort 5000 monsters…Sort complete with:      66495 comparisons       4613 block copies     130807 total copies          0 swaps        255 allocations       0.00s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 5000, all sorts, by nameBubble sort 5000 monsters by name…Sort complete with:   12497500 comparisons          0 block copies          0 total copies    6192642 swaps          0 allocations       0.27s CPU time usedThe list is sorted.Selection sort 5000 monsters by name…Sort complete with:   12502499 comparisons          0 block copies          0 total copies       4985 swaps          0 allocations       0.14s CPU time usedThe list is sorted.Insertion sort 5000 monsters by name…Sort complete with:    6309847 comparisons       4989 block copies   12504634 total copies          0 swaps          0 allocations       0.07s CPU time usedThe list is sorted.Quick sort 5000 monsters by name…Sort complete with:      72505 comparisons          0 block copies          0 total copies      37023 swaps          0 allocations       0.00s CPU time usedThe list is sorted.Merge sort 5000 monsters…Sort complete with:      55211 comparisons       9998 block copies     123616 total copies          0 swaps       4999 allocations       0.00s CPU time usedThe list is sorted.Merge-insertion sort 5000 monsters…Sort complete with:      66495 comparisons       4557 block copies     130261 total copies          0 swaps        255 allocations       0.00s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 50000, fast sorts only, by weightQuick sort 50000 monsters by weight…Sort complete with:     987691 comparisons          0 block copies          0 total copies     532031 swaps          0 allocations       0.01s CPU time usedThe list is sorted.Merge sort 50000 monsters…Sort complete with:     718237 comparisons      99998 block copies    1568928 total copies          0 swaps      49999 allocations       0.03s CPU time usedThe list is sorted.Merge-insertion sort 50000 monsters…Sort complete with:     879991 comparisons      46350 block copies    1728408 total copies          0 swaps       2047 allocations       0.02s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 50000, fast sorts only, by nameQuick sort 50000 monsters by name…Sort complete with:     893834 comparisons          0 block copies          0 total copies     466440 swaps          0 allocations       0.02s CPU time usedThe list is sorted.Merge sort 50000 monsters…Sort complete with:     718359 comparisons      99998 block copies    1568928 total copies          0 swaps      49999 allocations       0.03s CPU time usedThe list is sorted.Merge-insertion sort 50000 monsters…Sort complete with:     881390 comparisons      46301 block copies    1727292 total copies          0 swaps       2047 allocations       0.03s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 500000, fast sorts only, by weightQuick sort 500000 monsters by weight…Sort complete with:   13917955 comparisons          0 block copies          0 total copies    5713813 swaps          0 allocations       0.20s CPU time usedThe list is sorted.Merge sort 500000 monsters…Sort complete with:    8837258 comparisons     999998 block copies   18951424 total copies          0 swaps     499999 allocations       0.37s CPU time usedThe list is sorted.Merge-insertion sort 500000 monsters…Sort complete with:    9611835 comparisons     456503 block copies   18960147 total copies          0 swaps      32767 allocations       0.31s CPU time usedThe list is sorted.SORT SET COMPLETESORT SET: n = 500000, fast sorts only, by nameQuick sort 500000 monsters by name…Sort complete with:   13304083 comparisons          0 block copies          0 total copies    5434003 swaps          0 allocations       0.27s CPU time usedThe list is sorted.Merge sort 500000 monsters…Sort complete with:    8837110 comparisons     999998 block copies   18951424 total copies          0 swaps     499999 allocations       0.42s CPU time usedThe list is sorted.Merge-insertion sort 500000 monsters…Sort complete with:    9609392 comparisons     456619 block copies   18961460 total copies          0 swaps      32767 allocations       0.37s CPU time usedThe list is sorted.SORT SET COMPLETEINTEGER SORT#include #include #include #include #include #include /* Friends from main. */extern int Comparisons;extern int Copies;extern int Block_Copies;extern int Swaps;extern int Mallocs;extern clock_t Start_Cpu;void clear_stats();void print_stats();/* Swap two integers in an array. */void swap_integers(int *list, int i, int j){ int temp; temp = list[i]; list[i] = list[j]; list[j] = temp; Swaps++;}/* Implement ascending quick sort. */int repartition(int *list, int low_index, int high_index){ /* If the array is random, it doesn’t actually matter what we pick for the pivot_index. However, there’s one quirk: if we pick the lowest number, Quick Sort has the worst possible performance. Since we often get already-sorted lists, we want to *NOT* pick the first item. There are arguments for picking the median and for picking other more complicated things, but for our purposes, it usually works to just pick the last item – and it’s simple to code. */ int pivot_value = list[high_index]; /* We already know our pivot_value. What we’re going to do is fill the lower elements of the array with the values below pivot_value, and let the number of them we encounter determine our eventual pivot index. */ int i = low_index; for(int j = low_index; j < high_index; j++) { Comparisons++; if(list[j] < pivot_value) { swap_integers(list, i, j); i++; } } /* We've now placed everything below pivot_value in list[low_index..i-1] - and that means we can just put our pivot value in list[i]! */ swap_integers(list, i, high_index); return i;}/* Recursive function for quick sort. */void quick_sort_recursive(int *list, int low_index, int high_index){ int pivot_index = repartition(list, low_index, high_index); // Coming out of repartition, our pivot_index must already be in the right position. if(pivot_index-1 > low_index) quick_sort_recursive(list, low_index, pivot_index-1); if(high_index > pivot_index+1) quick_sort_recursive(list, pivot_index+1, high_index);}/* Shell function for quick sort. */void quick_sort(int *list, int n){ printf(“Quick sort %d integers…n”, n); clear_stats(); quick_sort_recursive(list, 0, n-1); print_stats();}/* Implement ascending bubble sort. */void bubble_sort(int *list, int n){ int i; int j; printf(“Bubble sort %d integers…n”, n); clear_stats(); for(i = n-1; i >= 0; i–) { for(j = 0; j < i; j++) { Comparisons++; if(list[j] > list[j+1]) // Are our elements out of order? { swap_integers(list, j, j+1); } } } print_stats();}/* Highest-value finder for selection sort. */int find_highest(int *list, int n){ int highest_val = INT_MIN; int highest_loc = -1; int i; for(i = 0; i <= n; i++) { Comparisons++; if(list[i] > highest_val) { highest_loc = i; highest_val = list[i]; } } return highest_loc;}/* Implement ascending selection sort. */void selection_sort(int *list, int n){ int i; int highest; printf(“Selection sort %d integers…n”, n); clear_stats(); for(i = n-1; i > 0; i–) { highest = find_highest(list, i); if(highest != i) { swap_integers(list, highest, i); } } print_stats();}/* Find position for insertion sort. */int insertion_sort_find_position(int *list, int low_index, int high_index, int k){ // Implement this function.}void insertion_sort_internal(int *list, int n){ // Implement this function.}/* Implement insertion sort. */void insertion_sort(int *list, int n){ clear_stats(); printf(“Insertion sort %d integers…n”, n); insertion_sort_internal(list, n); print_stats(); return;}void merge_sort_merge(int *list, int l1, int h1, int l2, int h2){ // Implement this function.}/* Recursive function for merge sort. */void merge_sort_recursive(int *list, int low_index, int high_index){ // Implement this function.}/* Implement merge sort. */void merge_sort(int *list, int n){ printf(“Merge sort %d integers…n”, n); clear_stats(); merge_sort_recursive(list, 0, n-1); print_stats();}/* Recursive function for merge-insertion sort. */void merge_insertion_sort_recursive(int *list, int low_index, int high_index){ // Implement this function.}/* Implement merge sort. */void merge_insertion_sort(int *list, int n){ printf(“Merge-insertion sort %d integers…n”, n); clear_stats(); merge_insertion_sort_recursive(list, 0, n-1); print_stats();}// integer-sorts.c – demonstrate basic sorting algorithms/* The idea of sorting is simple: take unordered objects, and arrange them in an order. It has a lot of uses, so there’s been a lot of work done with it. Here, we’re going to demonstrate a few of the simpler, more classic sorting techniques. */#include #include #include #include #include #include #include “leak_detector_c.h”void quick_sort(int *list, int n);void bubble_sort(int *list, int n);void selection_sort(int *list, int n);void insertion_sort(int *list, int n);void merge_sort(int *list, int n);void merge_insertion_sort(int *list, int n);/* Tracking functions. */int Comparisons;int Copies;int Block_Copies;int Swaps;int Mallocs;clock_t Start_Cpu;void clear_stats(){ Comparisons = 0; Copies = 0; Block_Copies = 0; Swaps = 0; Mallocs = 0; Start_Cpu = clock();}void print_stats(){ clock_t end_cpu = clock(); printf(“Sort complete with:n”); printf(” %10d comparisonsn”, Comparisons); printf(” %10d block copiesn”, Block_Copies); printf(” %10d total copiesn”, Copies); printf(” %10d swapsn”, Swaps); printf(” %10d allocationsn”, Mallocs); printf(” %10.2lfs CPU time usedn”, ((double) (end_cpu – Start_Cpu)) / CLOCKS_PER_SEC);}/* Output a list of integers. */void output_integer_list(int *list, int n, char *title) { printf(“List %s:n”, title); for(int i = 0; i < n; i++) { printf(" Value %3d: %10dn", i, list[i]); } printf("n");}int *make_some_integers(int n){ int *integers = malloc(sizeof(int) * n); time_t t; srand((unsigned) time(&t)); for(int i = 0; i < n; i++) { integers[i] = rand(); } return integers;}/* Main program. */int main(void) { atexit(report_mem_leak); int n = 50000; int *our_list = make_some_integers(n); int *our_unsorted_list = malloc(sizeof(int) * n);// output_integer_list(our_list, n, "unsorted values"); memcpy(our_unsorted_list, our_list, sizeof(int) * n); bubble_sort(our_unsorted_list, n); memcpy(our_unsorted_list, our_list, sizeof(int) * n); selection_sort(our_unsorted_list, n); memcpy(our_unsorted_list, our_list, sizeof(int) * n); quick_sort(our_unsorted_list, n); memcpy(our_unsorted_list, our_list, sizeof(int) * n); insertion_sort(our_unsorted_list, n); memcpy(our_unsorted_list, our_list, sizeof(int) * n); merge_sort(our_unsorted_list, n); memcpy(our_unsorted_list, our_list, sizeof(int) * n); merge_insertion_sort(our_unsorted_list, n);// output_integer_list(our_unsorted_list, n, "sorted values"); free(our_list); free(our_unsorted_list); return 0;}monster sort#include "monster-sorts.h"void print_clocks(clock_t clocks) { printf(" %lfs CPU time usedn", ((double) clocks) / CLOCKS_PER_SEC);}void swap_monsters(monster *list, int i, int j){ monster temp; memcpy(&temp, list + i, sizeof(monster)); memcpy(list + i, list + j, sizeof(monster)); memcpy(list + j, &temp, sizeof(monster)); Swaps++;}/* The core comparison function. */int compare_monsters(monster *m1, monster *m2, int use_name, int use_weight){ // Implement this function.}/* Implement ascending quick sort. */int repartition(monster *list, int low_index, int high_index, int use_name, int use_weight){ // Implement this function.}/* Recursive function for quick sort. */void quick_sort_recursive(monster *list, int low_index, int high_index, int use_name, int use_weight){ // Implement this function.}/* Shell function for quick sort. */void quick_sort(monster *list, int n, int use_name, int use_weight){ printf("Quick sort %d monsters by %s...n", n, use_name ? "name" : "weight"); clear_stats(); quick_sort_recursive(list, 0, n-1, use_name, use_weight); print_stats();}/* Implement ascending bubble sort. */void bubble_sort(monster *list, int n, int use_name, int use_weight){ // Your variables go here. printf("Bubble sort %d monsters by %s...n", n, use_name ? "name" : "weight"); clear_stats(); // Implement this function. print_stats();}/* Highest-value finder for selection sort. */int find_highest(monster *list, int n, int use_name, int use_weight){ // Implement this function.}/* Implement ascending selection sort. */void selection_sort(monster *list, int n, int use_name, int use_weight){ // Your variables go here. printf("Selection sort %d monsters by %s...n", n, use_name ? "name" : "weight"); clear_stats(); // Implement this function. print_stats();}/* Find position for insertion sort. */int insertion_sort_find_position(monster *list, int low_index, int high_index, monster *k, int use_name, int use_weight){ // Implement this function.}/* Implement insertion sort. */void insertion_sort_internal(monster *list, int n, int use_name, int use_weight){ // Implement this function.}/* Shell for insertion sort. */void insertion_sort(monster *list, int n, int use_name, int use_weight){ printf("Insertion sort %d monsters by %s...n", n, use_name ? "name" : "weight"); clear_stats(); insertion_sort_internal(list, n, use_name, use_weight); print_stats(); return;}/* Merge function for merge sort. Merges sub-arrays [l1..h1] and [l2..h2]. Must have l2 = l1 + 1 or bad things will happen. */void merge_sort_merge(monster *list, int l1, int h1, int l2, int h2, int use_name, int use_weight){ // Implement this function.}/* Recursive function for merge sort. */void merge_sort_recursive(monster *list, int low_index, int high_index, int use_name, int use_weight){ // Implement this function.}/* Implement merge sort. */void merge_sort(monster *list, int n, int use_name, int use_weight){ printf(“Merge sort %d monsters…n”, n); clear_stats(); merge_sort_recursive(list, 0, n-1, use_name, use_weight); print_stats();}/* Recursive function for merge-insertion sort. */void merge_insertion_sort_recursive(monster *list, int low_index, int high_index, int use_name, int use_weight){ // Implement this function.}/* Implement merge-insertion sort. */void merge_insertion_sort(monster *list, int n, int use_name, int use_weight){ clear_stats(); printf(“Merge-insertion sort %d monsters…n”, n); merge_insertion_sort_recursive(list, 0, n-1, use_name, use_weight); print_stats();}// all-monster-sorts.c – Sort monsters by name and weight./* The idea of sorting is simple: take unordered objects, and arrange them in an order. It has a lot of uses, so there’s been a lot of work done with it. Here, we’re going to demonstrate a few of the simpler, more classic sorting techniques. */#include “monster-sorts.h”/* Tracking functions. */int Comparisons;int Copies;int Block_Copies;int Swaps;int Mallocs;clock_t Start_Cpu;void clear_stats(){ Comparisons = 0; Copies = 0; Block_Copies = 0; Swaps = 0; Mallocs = 0; Start_Cpu = clock();}void print_stats(){ clock_t end_cpu = clock(); printf(“Sort complete with:n”); printf(” %10d comparisonsn”, Comparisons); printf(” %10d block copiesn”, Block_Copies); printf(” %10d total copiesn”, Copies); printf(” %10d swapsn”, Swaps); printf(” %10d allocationsn”, Mallocs); printf(” %10.2lfs CPU time usedn”, ((double) (end_cpu – Start_Cpu)) / CLOCKS_PER_SEC);}monster *make_some_monsters(int n){ monster *monsters = malloc(sizeof(monster) * n); time_t t; srand((unsigned) time(&t)); for(int i = 0; i < n; i++) { monsters[i].id = i; sprintf(monsters[i].name, "Monster #%d", rand()); sprintf(monsters[i].element, "Element #%d", rand()); monsters[i].population = rand(); monsters[i].weight = 500.0 * ((double) rand() / (double) RAND_MAX); } return monsters;}void output_monster_list(monster *list, int n, char *title) { printf("List %s:n", title); for(int i = 0; i < n; i++) { printf(" Monster %d: %s %s %d %lfn", i, list[i].name, list[i].element, list[i].population, list[i].weight); } printf("n");}/* Check whether a list is sorted. */void check_monster_sort(monster *list, int n, int use_name, int use_weight){ for(int i = 1; i < n; i++) { if(compare_monsters(list + i - 1, list + i, use_name, use_weight) > 0) { printf(“*** The list is NOT sorted.nn”); return; } } printf(“The list is sorted.nn”);}/* Main program. */void run_all_sorts(int n, int only_fast, int use_name, int use_weight) { monster *our_list = make_some_monsters(n); monster *our_unsorted_list = malloc(sizeof(monster) * n); printf(“SORT SET: n = %d, %s, by %snn”, n, only_fast ? “fast sorts only” : “all sorts”, use_name ? “name” : “weight”); if(only_fast == 0) { memcpy(our_unsorted_list, our_list, sizeof(monster) * n); bubble_sort(our_unsorted_list, n, use_name, use_weight); check_monster_sort(our_unsorted_list, n, use_name, use_weight); memcpy(our_unsorted_list, our_list, sizeof(monster) * n); selection_sort(our_unsorted_list, n, use_name, use_weight); check_monster_sort(our_unsorted_list, n, use_name, use_weight); memcpy(our_unsorted_list, our_list, sizeof(monster) * n); insertion_sort(our_unsorted_list, n, use_name, use_weight); check_monster_sort(our_unsorted_list, n, use_name, use_weight); } memcpy(our_unsorted_list, our_list, sizeof(monster) * n); quick_sort(our_unsorted_list, n, use_name, use_weight); check_monster_sort(our_unsorted_list, n, use_name, use_weight); memcpy(our_unsorted_list, our_list, sizeof(monster) * n); merge_sort(our_unsorted_list, n, use_name, use_weight); check_monster_sort(our_unsorted_list, n, use_name, use_weight); memcpy(our_unsorted_list, our_list, sizeof(monster) * n); merge_insertion_sort(our_unsorted_list, n, use_name, use_weight); check_monster_sort(our_unsorted_list, n, use_name, use_weight); printf(“SORT SET COMPLETEnn”); free(our_list); free(our_unsorted_list);}int main(void) { atexit(report_mem_leak); run_all_sorts(50, 0, 0, 1); run_all_sorts(50, 0, 1, 0); run_all_sorts(500, 0, 0, 1); run_all_sorts(500, 0, 1, 0); run_all_sorts(5000, 0, 0, 1); run_all_sorts(5000, 0, 1, 0); run_all_sorts(50000, 1, 0, 1); run_all_sorts(50000, 1, 1, 0); run_all_sorts(500000, 1, 0, 1); run_all_sorts(500000, 1, 1, 0);}Engineering & TechnologyComputer ScienceCOP 3502Share Question

How it works

1. Paste your instructions in the instructions box. You can also attach an instructions file
2. Select the writer category, deadline, education level and review the instructions 
3. Make a payment for the order to be assignment to a writer
4.  Download the paper after the writer uploads it 

Will the writer plagiarize my essay?

You will get a plagiarism-free paper and you can get an originality report upon request.

Is this service safe?

All the personal information is confidential and we have 100% safe payment methods. We also guarantee good grades