C++ (Cpp) sorter_bubble_sort Beispiele

Beispiel #1

Datei: stresstest.c Projekt: blackball/sort

void run_tests(int64_t *sizes, int sizes_cnt, int type)
{
  int test, res;
  double usec1, usec2, diff;

  printf("-------\nRunning tests with %s:\n-------\n", test_names[type]);

  res = 0;
  diff = 0;
  printf("%-20s", "stdlib qsort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    qsort(dst, size, sizeof(int64_t), simple_cmp);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

#ifndef __linux__
  res = 0;
  diff = 0;
  printf("%-20s", "stdlib heapsort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    heapsort(dst, size, sizeof(int64_t), simple_cmp);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

  res = 0;
  diff = 0;
  printf("%-20s", "stdlib mergesort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    mergesort(dst, size, sizeof(int64_t), simple_cmp);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

#endif
  res = 0;
  diff = 0;
  printf("%-20s", "quick sort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_quick_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  } 
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
    
  if (MAXSIZE < 10000)
  {
	  res = 0;
	  diff = 0;
    printf("%-20s", "bubble sort");
    for (test = 0; test < sizes_cnt; test++)
    {
      int64_t size = sizes[test];
      int64_t dst[size];
      fill(dst, size, type);
	  usec1 = utime();
      sorter_bubble_sort(dst, size);
	  usec2 = utime();
      verify(dst, size);
	if (!res) break;
	  diff += usec2 - usec1;
    }
	printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

	res = 0;
	diff = 0;
    printf("%-20s", "binary insertion sort\n");
    for (test = 0; test < sizes_cnt; test++)
    {
      int64_t size = sizes[test];
      int64_t dst[size];
      fill(dst, size, type);
	  usec1 = utime();
      sorter_binary_insertion_sort(dst, size);
	  usec2 = utime();
      verify(dst, size);
	if (!res) break;
	  diff += usec2 - usec1;
    }
	printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
  }
      
  res = 0;
  diff = 0;
  printf("%-20s", "merge sort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_merge_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
    
   
  res = 0;
  diff = 0;
  printf("%-20s", "heap sort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_heap_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
    
  res = 0;
  diff = 0;
  printf("%-20s", "shell sort time");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_shell_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
    
  res = 0;
  diff = 0;
  printf("%-20s", "tim sort"); 
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_tim_sort(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);

  res = 0;
  diff = 0;
  printf("%-20s", "in-place merge sort");
  for (test = 0; test < sizes_cnt; test++)
  {
    int64_t size = sizes[test];
    int64_t dst[size];
    fill(dst, size, type);
	usec1 = utime();
    sorter_merge_sort_in_place(dst, size);
	usec2 = utime();
    res = verify(dst, size);
	if (!res) break;
	diff += usec2 - usec1;
  }
  printf(" - %s, %10.1f usec\n", res ? "ok" : "FAILED", diff);
}

Beispiel #2

Datei: multidemo.c Projekt: TRANE73/sort

void run_tests(void) {
  int i;
  int64_t arr[SIZE];
  int64_t dst[SIZE];
  double start_time;
  double end_time;
  double total_time;

  printf("Running tests\n");
  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    qsort(dst, SIZE, sizeof(int64_t), simple_cmp);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("stdlib qsort time: %.2f us per iteration\n", total_time / RUNS);

#ifndef __linux__
  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    heapsort(dst, SIZE, sizeof(int64_t), simple_cmp);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("stdlib heapsort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    mergesort(dst, SIZE, sizeof(int64_t), simple_cmp);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("stdlib mergesort time: %.2f us per iteration\n", total_time / RUNS);
#endif

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter_quick_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("quick sort time: %.2f us per iteration\n", total_time / RUNS);


  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter_bubble_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("bubble sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter_merge_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("merge sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter_binary_insertion_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("binary insertion sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter_heap_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("heap sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter_shell_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("shell sort time: %.2f us per iteration\n", total_time / RUNS);

  srand48(SEED);
  total_time = 0.0;
  for (i = 0; i < RUNS; i++) {
    fill(arr, SIZE);
    memcpy(dst, arr, sizeof(int64_t) * SIZE);
    start_time = utime();

    sorter_tim_sort(dst, SIZE);

    end_time = utime();
    total_time += end_time - start_time;
    verify(dst, SIZE);
  }
  printf("tim sort time: %.2f us per iteration\n", total_time / RUNS);
}