Question

我正在研究我的前几个算法来构建我的C ++技能，目前正在编写一种使用合并排序计算反转的方法。我已经成功地将一个合并排序组合在一起，但是我在跟踪反转次数方面遇到了一些麻烦。从这里开始的任何想法？如何跟踪这样的递归算法的反转次数？另外我在网上旅行中看到了几个不同的实现，并且发现大多数人偏离了std :: vector方法，任何想法为什么？感谢您的帮助，我的代码如下！

#include <iostream>
#include <math.h>
#include <vector>

using namespace std;

vector<int> print(vector<int> input){

    for(int i=0; i<input.size(); i++){
        cout<<input[i]<<",";
    }
    cout<<endl;
    return input;
}


vector<int> merge(vector<int> left,vector<int> right){

    //set up some varibles
    vector<int> output;
    int i=0;
    int j=0;

    //loop through the lists and merge
    while(i<left.size() && j<right.size()){

        //push the smallest of the two to the vector output
        if(left[i]<=right[j]){
            output.push_back(left[i]);
            i+=1;
        }
        if(left[i]>right[i]){
            output.push_back(right[j]);
            j+=1;
        }
    }

    //push the remnants of the vectors to output
    for(i; i<left.size(); i++){
        output.push_back(left[i]);
    }

    for(j; j<right.size(); j++){
        output.push_back(right[j]);
    }

    return output;
}//end merge

vector<int> merge_sort(vector<int> input){
    //check the size of the vector
    if(input.size()<2){
        return input;
    }

    else{

    //int new vectors
    vector<int> left;
    vector<int> right;
    vector<int> output;

    //find the middle of the input vector
    int middle=(input.size())/2;

    //build the left vector
    for(int i=0; i<middle; i++){
        left.push_back(input[i]);
    }

    //build the right vector
    for(int i=middle; i<input.size(); i++){
        right.push_back(input[i]);
    }

    //make recursive calls
    left=merge_sort(left);
    right=merge_sort(right);

    //call merge
    output=merge(left,right);


    return output;
    }
}


int main()
{
    vector<int> output;
    vector<int> input;

    input.push_back(2);
    input.push_back(1);
    input.push_back(10);
    input.push_back(4);

    output=merge_sort(input);

    print(output);


}

Answer 1

好消息：从这里开始计算倒数很容易。

考虑一下你的＆＃34;合并＆＃34;方法。每次将左边向量中的元素放入输出时，都不会相对于右边的元素更改其位置。另一方面，每次你从右边的矢量中添加一个元素时，你都会在＆＃34;之前添加一个元素。所有元素仍然需要在左边的矢量中处理，当它在＃34;之后＃34;他们，即创建（left.size - i）＆＃34;反转＆＃34;。

如果需要，您可以通过归纳轻松证明这一点。

所以答案很简单：将int *传递给merge方法，并在每次从右向量推送元素时将其递增（left.size - i）。

编辑：工作代码示例

#include <iostream>
#include <vector>
// removed useless dependency math.h

using namespace std;

// void type -> does not return anything
void print (vector<int> input) {
    // range-based for loop (since C++ 11)
    // no brackets -> only one instruction in for loop
    for(int i : input)
        cout << i << ",";
}

vector<int> merge (vector<int> left, vector<int> right, int * inv_count) {
    vector<int> output;
    // multiple variable definition of the same type
    int i=0, j=0;

    // spaces around "<", after "while", before "{" for readability
    while (i < left.size() && j < right.size()) {

        // one-instruction trick again
        if (left[i] <= right[j])
            // i++ is evaluated to <previous value of i> and then increments i
            // this is strictly equivalent to your code, but shorter
            // check the difference with ++i
            output.push_back(left[i++]);
        // else because the two conditions were complementary
        else {
            output.push_back(right[j++]);
            // pointer incrementation
            *inv_count += (left.size() - i);
        }
    }

    // first field of for ommited because there is no need to initialize i
    for(; i < left.size(); i++)
        output.push_back(left[i]);

    for(; j < right.size(); j++)
        output.push_back(right[j]);

    return output;
}

vector<int> merge_sort (vector<int> input, int * inv_count) {
    // no-braces-idiom again
    // spaces around "<" and after "if" for readability
    if (input.size() < 2)
        return input;

    // no need for else keyword because of the return

    // multiple variable definition
    vector<int> left, right;

    int middle = input.size() / 2;

    // one-instruction for loop
    for(int i=0; i < middle; i++)
        left.push_back(input[i]);

    for(int i=middle; i < input.size(); i++)
        right.push_back(input[i]);

    // no need for intermediate variable
    return merge( merge_sort(left, inv_count),
                  merge_sort(right, inv_count),
                  inv_count);
}

// consistent convention : brace on the same line as function name with a space
int main () {
    // vector initialization (valid only since C++ 11)
    vector<int> input = {2, 1, 10, 4, 42, 3, 21, 7};

    int inv_count = 0;

    // No need for intermediate variables again, you can chain functions
    print( merge_sort(input, &inv_count) );

    // The value inv_count was modified although not returned
    cout << "-> " << inv_count << " inversions" << endl;
}

我修改了你的代码以包含一些常用的C ++习语。因为您使用了C ++ 14标记，所以我也使用了自C ++ 11以来可用的技巧。我不建议在所有地方使用所有这些技巧，因为这是一个很好的学习经历，所以它们都包含在这里。

我建议你在深入了解C ++之前阅读有关指针的内容。

另请注意，此代码绝不是最佳的：创建了太多的中间向量，这里的向量没用，数组就足够了。但是我会再把它留下来。

使用C ++中的合并排序计算Inversions

1 个答案: