C++ 排序方法的奇怪运行时结果

我有迭代合并排序、合并排序、快速排序、插入排序和冒泡排序

理想情况下，我认为运行时应该是：

迭代合并排序>快速排序>合并排序>插入排序~气泡排序

void BubbleSort(vector<int> &items, int beginIndex, int endIndex)
{
bool Swapped = true;
int n = (int)items.size();
while(Swapped)
{
    Swapped = false;
    for(int index = 1; index < n; index++)
    {
        if(items[index - 1] > items[index])
        {
            Swap(items, index - 1, index);
            Swapped = true;
        }
    }
    n = n - 1;
    }
}

void Swap(vector<int> &items, int a, int b)
{
int temp = items[a];
items[a] = items[b];
items[b] = temp;
}

然而，在插入排序和冒泡排序方面，我始终获得最快的运行时间。 你能帮我找出为什么我会得到这样的结果吗

我的测试按以下顺序运行：

迭代合并排序->合并排序->快速排序->插入排序->冒泡排序

void BubbleSort(vector<int> &items, int beginIndex, int endIndex)
{
bool Swapped = true;
int n = (int)items.size();
while(Swapped)
{
    Swapped = false;
    for(int index = 1; index < n; index++)
    {
        if(items[index - 1] > items[index])
        {
            Swap(items, index - 1, index);
            Swapped = true;
        }
    }
    n = n - 1;
    }
}

void Swap(vector<int> &items, int a, int b)
{
int temp = items[a];
items[a] = items[b];
items[b] = temp;
}

完成每次排序（10次）后，我计算平均运行时间

结果如下：

Sort employed: IterativeMergeSort
Average: 1574446
Sort employed: MergeSort
Average: 1728212
Sort employed: QuickSort
Average: 1002544
Sort employed: InsertSort
Average: 681322
Sort employed: BubbleSort
Average: 966246

这是我的分类代码： 迭代合并排序

void IterativeMergeSort(vector<int> &items, int beginIndex, int endIndex)
{
    if(items.size() < 2)
    {
        return;
    }
    else
    {
        int num = endIndex + 1;
        int mid, right;
        for(int size = 1; size < num; size *= 2)
    {
        for(int left = 0; left < num - size; left += (size*2))
        {
            mid = left + (size - 1);
            if( mid >= num)
            {
                mid = num - 1;
            }
            right = left + ((2 * size) - 1);

            if( right >= num)
            {
                right = num - 1;
            }

            IterativeMerge(items, left, mid, right);
            }
        }
    }
}

void IterativeMerge(vector<int> &items, int start, int mid, int end)
{
vector<int> temp(items.size());
int tempIndex = start;
int leftIndex = start;
int rightIndex = mid+1;
while (leftIndex <= mid && rightIndex <= end)
{
    if(items[leftIndex] <= items[rightIndex])
    {
        temp[tempIndex] = items[leftIndex];
        leftIndex++;
    }
    else
    {
        temp[tempIndex] = items[rightIndex];
        rightIndex++;
    }
    tempIndex++;
}
while (leftIndex <= mid)
{
    temp[tempIndex] = items[leftIndex];
    leftIndex++;
    tempIndex++;
}
while(rightIndex <= end)
{
    temp[tempIndex] = items[rightIndex];
    rightIndex++;
    tempIndex++;
}
for(tempIndex = start; tempIndex <= end; tempIndex++)
{
    items[tempIndex] = temp[tempIndex];
    }
}

void MergeSort(vector<int> &items, int beginIndex, int endIndex)
{
if(beginIndex < endIndex)
{
    int mid = beginIndex + (endIndex - beginIndex) / 2;
    MergeSort(items, beginIndex, mid);
    MergeSort(items, mid + 1, endIndex);
    Merge(items, beginIndex, mid, endIndex);
    }
}

void Merge(vector<int> &items, int first, int mid, int last)
{
vector<int> temp(items.size(), 0);

int first1 = first;
int last1 = mid;
int first2 = mid + 1;
int last2= last;

int index = first1;

while ((first1 <= last1) && (first2 <= last2))
{
    if(items[first1] <= items[first2])
    {
        temp[index] = items[first1];
        first1++;
    }
    else
    {
        temp[index] = items[first2];
        first2++;
    }
    index++;
}

while(first1 <= last1)
{
    temp[index] = items[first1];
    first1++;
    index++;
}

while(first2 <= last2)
{
    temp[index] = items[first2];
    first2++;
    index++;
}

for(index = first; index <= last; index++){
    items[index] = temp[index];
    }
}

void IterativeMergeSort（向量和项、int-beginIndex、int-endIndex）
{
if（items.size（）<2）
{
返回；
}
其他的
{
int num=endIndex+1；
int mid，对；
对于（int size=1；size=num）
{
mid=num-1；
}
右=左+（（2*尺寸）-1）；
如果（右>=num）
{
右=num-1；
}
迭代合并（项目、左、中、右）；
}
}
}
}
void IterativeMerge（向量和项、整数开始、整数中间、整数结束）
{
向量温度（items.size（））；
int tempIndex=开始；
int leftIndex=start；
int rightIndex=mid+1；
虽然（leftIndex您是如何初始化向量的？列表中有多少项？它们被初始化为随机顺序整数，在0和给定大小之间没有重复项。例如，大小10，0到9。对于给定结果，向量大小为10000您包含了大量排序代码，但忽略了发布您正在设置的测试装备对于排序，以及您用于测量性能的方法和代码，请注意，如果您在每次插入时对已排序的子序列使用二进制搜索，则插入排序可以显著改进。谢谢，我将使用用于测量运行时的代码更新问题。
void InsertSort(vector<int> &items, int beginIndex, int endIndex)
{
for(int place = 1; place < items.size(); place++)
{
    int temp = items[place];
    int i = place;
    while ((i > 0) && (items[i - 1] > temp))
    {
        items[i] = items[i - 1];
        i--;
    }
    items[i] = temp;
    }
}

void PrintArray(const vector<int> &, string name);
void InitArray(vector<int> &, int randMax);
int elapsed(timeval &, timeval &);

int main (int argc, char* argv[])
{
    int size = 10000;
    vector<string> sorts = {"QuickSort", "InsertSort", "BubbleSort", "IterativeMergeSort", "MergeSort"};
    for(int j = 0; j < sorts.size(); j++)
    {
    string sort_name = sorts[j];
    cout << "Sort employed: " << sort_name << endl;
    int sum;
    for(int i = 0; i < 10; i++)
    {
    srand(1);
vector<int> items(size);
InitArray(items, size);

struct timeval startTime, endTime;
gettimeofday(&startTime, 0);

if(sort_name == "MergeSort")
{
    MergeSort(items, 0, size - 1);
}

if(sort_name == "IterativeMergeSort")
{
    IterativeMergeSort(items, 0, size - 1);
}

if(sort_name == "QuickSort")
{
    QuickSort(items, 0, size - 1);
}

if(sort_name == "BubbleSort")
{
    BubbleSort(items, 0, size - 1);
}

if(sort_name == "InsertSort")
{
    InsertSort(items, 0, size - 1);
}

gettimeofday(&endTime, 0);
int elapsed_secs = elapsed(startTime, endTime);


    sum+=elapsed_secs;
}
    sum /= 10;
    cout << "Average: " << sum << endl;
}
return 0;
}

void InitArray(vector<int> &array, int randMax)
{
int size = array.size();
for(int i = 0; i < size;)
{
    int tmp = (randMax == -1) ? rand() : rand() % randMax;
    bool hit = false;
    for (int j = 0; j < i; j++)
    {
        if (array[j] == tmp)
        {
            hit = true;
            break;
        }
    }
    if(hit)
    {
        continue;
    }
    array[i] = tmp;
    i++;
}
}

void PrintArray(const vector<int> &array, string name)
{
int size = array.size();

for(int i = 0; i < size; i++)
    cout << name << "[" << i << "] = " << array[i] << endl;
}

int elapsed(timeval &startTime, timeval &endTime)
{
return (endTime.tv_sec - startTime.tv_sec) * 1000000
+ (endTime.tv_usec = startTime.tv_usec);
}