Question

我在C中实现了3个排序对数：冒泡排序，插入排序和快速排序。当我测试算法的运行时间时，插入常量的运行速度远远快于冒泡排序。我被引导相信它们应该在同一时间通过这个链接http://bigocheatsheet.com/
任何人都可以解释为什么插入排序更快？

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void insertSort(int arr[], int size){
    int temp, j, i;

    for (i = 1; i < size; i++){
        temp = arr[i];
        for (j = i; j > 0 && temp < arr[j - 1]; j--){
            arr[j] = arr[j - 1];
        }
        arr[j] = temp;
    }
}

void quicksort(int arr[], int first, int last){
    int pivot, j, temp, i;

    if (first < last){
        pivot = first;
        i = first;
        j = last;

        while (i < j){
            while (arr[i] <= arr[pivot] && i < last)
                i++;
            while (arr[j] > arr[pivot])
                j--;
            if (i < j){
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        temp = arr[pivot];
        arr[pivot] = arr[j];
        arr[j] = temp;
        quicksort(arr, first, j - 1);
        quicksort(arr, j + 1, last);
    }
}

void bubbleSort(int arr[], int size){
    int x = 0, y;

    for (x; x < size; x++){
        for (y = 0; y < size - 1; y++){
            if (arr[y] > arr[y + 1]){
                int temp = arr[y + 1];
                arr[y + 1] = arr[y];
                arr[y] = temp;
            }
        }
    }
}

void printArray(int arr[], int sizeArray){
    int i = 0;
    for (i; i < sizeArray; i++){
        printf("%i\n", arr[i]);
    }

    //  printf("\n");
    //  for (i = 0; i < number; i++){
    //      printf("bubbleNums[%d] = %d     ", i, *(bubbleNums + i));
    //      printf("insertNums[%d] = %d     ", i, *(insertNums + i));
    //      printf("quickNums[%d] = %d\n", i, *(quickNums + i));
    //  }
}

int main(){
    int *bubbleNums = (int *)malloc(100000 * sizeof(int)), *quickNums = (int *)malloc(100000 * sizeof(int)), *insertNums = (int *)malloc(100000 * sizeof(int));
    int number;
    int randNumber;
    int i = 0;

    printf("Enter a number: ");
    scanf(" %i", &number);

    printf("\n");
    srand(100);
    for (i; i < number; i++){
        randNumber = rand() % 100;
        bubbleNums[i] = randNumber;
        insertNums[i] = randNumber;
        quickNums[i] = randNumber;
        //      printf("bubbleNums[%d] = %d     ", i, *(bubbleNums + i));
        //      printf("insertNums[%d] = %d     ", i, *(insertNums + i));
        //      printf("quickNums[%d] = %d\n", i, *(quickNums + i));
    }

    printf("\n");
    clock_t t0 = clock();
    bubbleSort(bubbleNums, number);
    clock_t t1 = clock();
    printf("Time to sort bubblesort of %i elements: %d milliseconds\n", number, (t1 - t0));

    clock_t t2 = clock();
    insertSort(insertNums, number);
    clock_t t3 = clock();
    printf("Time to sort insertSort of %i elements: %d milliseconds\n", number, (t3 - t2));

    clock_t t4 = clock();
    quicksort(quickNums, 0, number - 1);
    clock_t t5 = clock();
    printf("Time to sort quicksort of %i elements: %d milliseconds\n", number, (t5 - t4));

        //printf("Bubble\n");
        //printArray(bubbleNums, number);
        //printf("Insert\n");
        //printArray(insertNums, number);
        //printf("Quick\n");
        //printArray(quickNums, number);

    getchar();
    getchar();

    return 0;
}

Answer 1

这可能是因为您的BubbleSort在列表排序时不会停止。您应该跟踪每次通过的更改次数。如果没有任何更改，则对列表进行排序。现在你迫使它总是有最糟糕的表现。

for (x; x < size; x++){
    int changes = 0;
    for (y = 0; y < size - 1; y++){
        if (arr[y] > arr[y + 1]){
            int temp = arr[y + 1];
            arr[y + 1] = arr[y];
            arr[y] = temp;
            changes++;
        }
    }
    if (changes == 0) {
        return;
    }
}

Answer 2

O（...）不包括常数乘数或低阶项。因此，如果一个方法的时间是2 xn ^ 2，另一个6 xn ^ 2 + 12 xn + 18，它们都被认为是O（n ^ 2），即使一个方法的速度超过3倍。其他

O（...）只是给出了特定算法的时间与n相关的一阶近似。

对于另一个问题，插入排序更快，因为它根据需要旋转数组的部分，而冒泡排序只交换对。

Answer 3

渐近复杂度告诉您性能如何扩展的问题大小。它没有告诉你任何关于同一任务的替代算法如何针对同一问题相互执行的事情。

插入排序是O（n ²）排序算法中最快的一种。虽然它的扩展方式与冒泡排序的方式相同，但插入排序往往会执行更少的比较和交换。少了多少取决于实现细节和输入。

气泡和插入之间的时间复杂性

3 个答案: