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

我在C中实现了3个排序对数：冒泡排序、插入排序和快速排序。当我测试算法的运行时间时，插入常数的运行速度远远快于冒泡排序。我相信他们应该在同一时间通过这个链接 有人能解释为什么插入排序要快得多吗

#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;
}

---

这可能是因为列表排序时，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;
    }
}

---

O。。。不包括常数乘数或低阶项。因此，如果一种方法的时间为2xn^2，另一种方法的时间为6xn^2+12xn+18，则它们都被视为在^2上，即使一种方法的速度是另一种方法的3倍多

世界。。。给出了一个一阶近似值，说明了特定算法的时间与n的关系

---

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

渐进复杂性告诉您性能如何随问题大小而变化。它并没有告诉您关于同一任务的替代算法相对于其他算法对于同一问题的执行情况

---

插入排序是On2排序算法中速度最快的一种。虽然它的伸缩方式与冒泡排序相同，但插入排序往往执行的比较和交换要少得多。减少多少取决于实现细节和输入。

这是用于修改气泡排序的算法。这是一个有效的版本，而且在这方面更好。即使我使用10000个元素的这个版本运行它，气泡排序也需要612毫秒，而插入需要119毫秒。我的一个朋友给了我一个建议，说这可能与分支有关，不知道怎么做。。。。。。我完全忘记了常数乘数。我已经很久没有做O记号了，我把它全忘了。非常感谢。