使用迭代器对向量进行 C++ 递归初始化会产生不一致的结果

Question

当我遇到不一致的程序行为时，我试图通过定义非常常见的归并排序算法来练习 C++ 迭代器。我的问题不是如何实现合并排序（我都知道并且也意识到有很多示例答案），而是在使用迭代器创建递归向量时我收到不一致的最终结果。

我知道我可以通过 for 循环将值复制到 L 和 R 数组来解决问题，但我想了解为什么使用迭代器不起作用。这是使用 C++ 14 的 CLION 上的运行。这个 post Best way to extract a subvector from a vector? 没有回答我的问题，因为我正在创建类似于规定方法的向量。

void merge2(vector<int> &arr, int l, int m, int r)
{
    vector<int> L{arr.begin()+l, arr.begin()+m+1};
    vector<int> R{arr.begin()+m+1,arr.begin()+r+1};
    int i = 0, j = 0, k = l;
    int n1 = m - l + 1;
    int n2 =  r - m;
    while (i < (n1) && j < (n2)){
        if (L[i]<=R[i]){ //R[i] is replaced by R[j]
            arr[k] = L[i++];
        }
        else {
            arr[k] = R[j++];
        }
        k++;
    }
    while  (i < n1)
    {
        arr[k] = L[i];
        i++;
        k++;
    }
    while(j < n2){
        arr[k] = R[j];
        j++;
        k++;
    }
}

/* l is for left index and r is right index of the
   sub-array of arr to be sorted */
void merge2Sort(vector<int> &arr, int l, int r)
{
    if (l < r)
    {
        // Same as (l+r)/2, but avoids overflow for
        // large l and h
//        int m = (l+r-l)/2;
//        int m = l+(r-l)/2;
            int m = (l+r)/2;
        // Sort first and second halves
        merge2Sort(arr, l, m);
        merge2Sort(arr, m+1, r);
        merge2(arr, l, m, r);
    }
}

int main(int argc, char **argv){
    vector<int> arr = {12, 11, 13, 5, 6, 7};
    merge2Sort(arr, 0, arr.size()-1);
    for(auto i = arr.begin(); i != arr.end(); i++){
        cout << *i << " ";
    }
    return 0;
}

有时我会收到正确答案 5 6 7 11 12 13，有时会收到错误答案 5 6 7 11 13 12。答案不应因尝试而异。

反映答案和评论的正确答案。答案更正索引错误并依赖于迭代器。还从评论中注意到，从迭代器初始化时的向量应该使用 () 而不是 {}。

template <class It>
void merge(It left, It middle, It right)
{
    // Beeing generic, you need to retrieve the type.
    using value_type = typename std::iterator_traits<It>::value_type;
    // You can copy only the first half 
    std::vector<value_type> left_side_copy(left, middle);
    It L = left_side_copy.begin();
    It R = middle;
    while (L != left_side_copy.end()  &&  R != right)
    {
        if ( *L <= *R )
        { 
            *left = *L;
            ++L;
        }
        else {
            *left = *R;
            ++R;
        }
        ++left;
    }
    // Copy only the leftovers, if there are any
    std::copy(L, left_side_copy.end(), left);
}

template <class It> 
void merge_sort(It left, It right)
{
    if (auto dist = std::distance(left, right); dist > 1)
    {
        It middle = left + dist / 2;
        merge_sort(left, middle);
        merge_sort(middle, right);
        merge(left, middle, right);
    }
}

int main(void)
{
    std::vector<int> arr {
        5, 12, 11, 13, 5, 4, 7, 13, 6
    };

    merge_sort(arr.begin(), arr.end());

    for(auto const &i : arr) {
        std::cout << ' ' << i;
    }
    std::cout << '\n';
}

Answer 1

您在向量 R 中使用索引 i 而不是 j。将 R[i] 替换为 R[j] 见下文

  void merge2(vector<int> &arr, int l, int m, int r)
    {
        //..
        while (i < (n1) && j < (n2)){
            if (L[i]<=R[j]){ //R[i] is replaced by R[j]
                arr[k] = L[i++];
            }
            else {
                arr[k] = R[j++];
            }
            k++;
        }

   //...
}

Answer 2

第 int m = l+(r-l)/2; 行不正确。你的意思可能是 int m = (l+r-l)/2; 虽然我认为保留 int m = (l+r)/2;.

会更好

使用迭代器对向量进行 C++ 递归初始化会产生不一致的结果

C++ recursive initialization of vectors using iterators produce inconsistent results

c++

iterator

c++11

clion