此合并排序算法执行多少个比较

How many compares does this Merge Sort algorithm do?

本文关键字：多少 比较 执行 算法 合并 排序      更新时间：2023-10-16

我想在此代码中添加compare++，以计算此算法完成了多少次比较。 在 Merge(...) 中的第一个 while 循环以及 while 中的if和else中，每次执行时是否需要增加compare计数？这些位置是否是唯一应该增加compare的位置？（我在我认为它所属的地方添加了这个增量并注释掉了。 请忽略交换功能）

#include "MergeSort.h"
template<class ItemType>
void MergeClass<ItemType>::sort(ItemType values[], int first, int last)
// Post: The elements in values are sorted by key.
{
    if (first < last)
    {
        int middle = (first + last) / 2;
        sort(values, first, middle);
        sort(values, middle + 1, last);
        Merge(values, first, middle, middle + 1, last);
    }
}
template<class ItemType>
void MergeClass<ItemType>::Merge(ItemType values[], int leftFirst, int leftLast,
int rightFirst, int rightLast)
// Post: values[leftFirst]..values[leftLast] and
// values[rightFirst]..values[rightLast] have been merged.
// values[leftFirst]..values[rightLast] are now sorted.
{
    ItemType tempArray[5];
    int index = leftFirst;
    int saveFirst = leftFirst;
    while ((leftFirst <= leftLast) && (rightFirst <= rightLast))
    {
        if (values[leftFirst] < values[rightFirst])
        {
            tempArray[index] = values[leftFirst];
            leftFirst++;
            //compare++;
        }
        else
        {
            tempArray[index] = values[rightFirst];
            rightFirst++;
            //compare++;
        }
        index++;
        //compare++;
    }
    while (leftFirst <= leftLast)
    // Copy remaining items from left half.
    {
        tempArray[index] = values[leftFirst];
        leftFirst++;
        index++;
    }
    while (rightFirst <= rightLast)
    // Copy remaining items from right half.
    {
        tempArray[index] = values[rightFirst];
        rightFirst++;
        index++;
    }
    for (index = saveFirst; index <= rightLast; index++)
        values[index] = tempArray[index];
}

template<class ItemType>
inline void MergeClass<ItemType>::Swap(ItemType& item1, ItemType& item2)
// Post: Contents of item1 and item2 have been swapped.
{
    ItemType tempItem;
    tempItem = item1;
    item1 = item2;
    item2 = tempItem;
}
template<class ItemType>
MergeClass<ItemType>::MergeClass()
{
    compare = 0;
    swap = 0;
}
template<class ItemType>
void MergeClass<ItemType>::sortPreformance()
{
    cout << "Comparisons made: " << compare <<endl;
    cout << "Swaps made: "<< swap <<endl;
}

如果它严格用于分析，我会将计数逻辑放在排序类之外。这类似于以下内容（仅计算std::sort使用的比较和交换次数）：

#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;
template<typename T>
struct CountingItem {
    CountingItem(const T& val = T()) : val_(val) {}
    bool operator<(const CountingItem<T>& rhs) const {
        ++compares;
        return val_ < rhs.val_;
    }
    static size_t compares;
    static size_t swaps;
    T val_;
};
template<typename T>
size_t CountingItem<T>::compares = 0;
template<typename T>
size_t CountingItem<T>::swaps = 0;
template<typename T>
void swap(CountingItem<T>& a, CountingItem<T>& b) {
    ++CountingItem<T>::swaps;
    std::swap(a, b);
}
int main()
{
    const size_t num_items = 10000;
    CountingItem<int> items[num_items];
    for(int i = 0; i < num_items; i++) items[i] = rand() % 100;
    sort(items, items+num_items);
    cout << "Compares = " << CountingItem<int>::compares << endl;
    cout << "Swaps    = " << CountingItem<int>::swaps << endl;
    // Reset CountingItem<int>::compares and swaps here if you're running another test
}
相关文章：