Question

我正在尝试使用stl库进行合并排序算法但是遇到了一些问题。以下是我正在使用的代码

template <typename Item, typename SizeType>
void merge_sort(Item array[], SizeType size){
    size_t n1; //Size of the first subarray
    size_t n2; //Size of the second subarray

    if(size > 1){
        //Compute the size of the subarrays
        n1 = size/2;
        n2 = size - n1;

        //create the temp array.
        int* n1Temp = new int[n1];
        int* n2Temp = new int[n2];
        int i;
        for(i = 0; i < n1; i++)
            n1Temp[i] = array[i];
        for(i = 0; i < n2; i++)
            n2Temp[i] = array[i + n1];

        //recursive calls
        merge_sort(n1Temp, n1);//sort from array[0] through array[n1 - 1] 
        merge_sort(n2Temp, n2);//sort from array[n1] to the end

        //Merge the two sorted halves.
        vector<int> v(array, array + size);
        merge(n1Temp, n1Temp + n1, n2Temp, n2Temp + n2, v.begin());     
        copy(v.begin(), v.end(), array);//copy the vector back to the array

        delete[] n1Temp;
        delete[] n2Temp;
    }
}

代码排序很好，但问题是它的行为类似于O（n ^ 2）算法而不是O（n \ log n），这是由于在每个合并排序调用中创建了向量（我认为）。我尝试删除向量，只使用合并函数中的数组，可以在下面看到

    //Merge the two sorted halves.
    int* finalArray = new int[n1 + n2];
    merge(n1Temp, n1Temp + n1, n2Temp, n2Temp + n2, begin(finalArray)); 
    array = finalArray;

但这只会让我感到错误。有什么办法可以挽救我的合并排序算法吗？

Answer 1

正如Vaughn和user93353都指出的那样，你应该能够在每个合并点直接合并到目标数组中。但你仍然可以使用std :: vector＆lt;＆gt;使你自己更容易。

此外，您的临时数组是直接类型'int'，我很确定它是模板参数Item的类型。我不确定SizeType参数的用途是什么，但是如果你对它有特别的想法我就离开了。无论是什么，它最好与size_t兼容：

template <typename Item, typename SizeType>
void merge_sort(Item array[], SizeType size)
{
    if(size > 1)
    {
        //Compute the size of the subarrays
        size_t n1 = size/2;

        //create the temp array
        std::vector<Item> n1Temp(array, array+n1);
        std::vector<Item> n2Temp(array+n1, array+size);

        //recursive calls
        merge_sort(&n1Temp[0], n1);       //sort array[0] through array[n1-1]
        merge_sort(&n2Temp[0], size-n1);  //sort array[n1] through array[size-1]

        // merge the sorted halves
        std::merge(n1Temp.begin(), n1Temp.end(),
                   n2Temp.begin(), n2Temp.end(), array);
    }
}

上述技术通过复制将子序列自上而下分割，然后将分割副本就地合并到原始数组中。您可以通过在原始数组上进行拆分，然后合并到临时空间并复制之后将该算法减少一个子列表 time （但不少空间），我认为

template <typename Item>
void merge_sort(Item ar[], size_t n)
{
    if (n > 1)
    {
        // Compute the size of the subarrays
        size_t n1 = n/2;

        // invoke recursion on the submerges
        merge_sort(ar, n1);      //sort array[0] through array[n1-1]
        merge_sort(ar+n1, n-n1); //sort array[n1] through array[size-1]

        // create merge-buffer
        std::vector<Item> mrg;
        std::merge(ar, ar+n1, ar+n1, ar+n, back_inserter(mrg));
        std::copy(mrg.begin(), mrg.end(), ar);
    }
}

基于迭代器的常规解决方案

对于允许更大灵活性的通用解决方案，您可以基于迭代器而不是Item指针来定义合并排序。它变得有点毛茸茸，但好处是std-lib-ish。

template <typename Iterator>
void merge_sort(Iterator first, Iterator last)
{
    typedef typename std::iterator_traits<Iterator>::value_type value_type;
    typedef typename std::iterator_traits<Iterator>::difference_type difference_type;

    difference_type n = std::distance(first, last)/2;
    if (n == 0)
        return;

    // invoke recursion on the submerges
    merge_sort(first, first + n);
    merge_sort(first + n, last);

    // create merge-buffer
    std::vector<value_type> mrg(std::distance(first, last));
    std::merge(first, first+n, first+n, last, mrg.begin());
    std::copy(mrg.begin(), mrg.end(), first);
}

最后，如果您发现自己排序了大量固定长度的C阵列，您可能会发现以下内容很有用（它使用上面的通用迭代器解决方案）：

// front-loader for C arrays
template<typename Item, size_t N>
void merge_sort(Item (&ar)[N])
{
    merge_sort(std::begin(ar), std::end(ar));
}

它使以下代码相当方便：

int arr[1024];
... fill arr ...
merge_sort(arr);

使用指向数组的指针合并排序

1 个答案: