Question

我需要删除Vector A和Vector B中出现的元素，但保留仅在Vector A中的元素。矢量可以是任何大小，但不一定相等。

例如，如果：向量A包含值＆lt; 1,4,66,22＆gt; 向量B包含值＆lt; 1,22,44,93,102,543＆gt;

然后在执行操作后：载体A应含有＆lt; 4,66＆gt;。载体B应含有＆lt; 44,93,102,543＆gt;

我是否需要使用for循环和strncmp循环这两个值，还是我可以用来简化流程的函数？这是我尝试过但似乎没有用的。

string rawInput;
string fileInput;
vector<string> stdInput; //vector to hold standard input values
vector<string> fileList; //vector to hold file values   

sizeIn = stdInput.size();
sizeFile = fileList.size(); 

if (sizeIn >= sizeFile)
    {
        for (count = 0;count <= sizeIn; count++)
        {
            for (count1 = 0; count1 <= sizeFile; count1++)
            {
                if (stdInput[count1] == fileList[count])
                {
                    stdInput.erase(stdInput.begin()+count1-1);
                    fileList.erase(fileList.begin()+count-1);

                }

            }
        }
    }
    else
    {
        for (count = 0; count <= sizeFile; count ++)
        {
            for (count1 = 0; count1 <= sizeIn; count1++)
            {
                if (stdInput[count] == fileList[count1])
                {
                    stdInput.erase(stdInput.begin()+count-1);
                    fileList.erase(fileList.begin()+count1-1);

                }   
            }
        }
    }

Answer 1

那里有很多工作要做。我会建议std::set_difference，但既然你想要这样做，这段代码将为你做好算法的复杂性：

template<typename T>
void remove_intersection(std::vector<T>& a, std::vector<T>& b){
    std::unordered_multiset<T> st;
    st.insert(a.begin(), a.end());
    st.insert(b.begin(), b.end());
    auto predicate = [&st](const T& k){ return st.count(k) > 1; };
    a.erase(std::remove_if(a.begin(), a.end(), predicate), a.end());
    b.erase(std::remove_if(b.begin(), b.end(), predicate), b.end());
}

不是C ++很漂亮吗？： - ）

演示：

int main(){
    std::vector<int> a = {1,4,66,22};
    std::vector<int> b = {1,22,44,93,102,543};

    remove_intersection(a, b);

    for(auto k : a) std::cout << k << ' ';
    std::cout << std::endl;
    for(auto k : b) std::cout << k << ' ';
}

输出：

4 66 
44 93 102 543

请参阅 Live On Coliru

上述方法有许多变化。例如，如果您担心count在这样的计数非常大时可能需要太长时间，那么您可以实现一个简单的函数来查找和计算最多2个元素;另一个：你可以简单地使用两个不同的无序集。

Answer 2

我可能会尝试以下内容。

// Create sets from vectors. This eliminates the duplicate elements.
const unordered_set<int> setA{vecA.cbegin(), vecA.cend()};
const unordered_set<int> setB{vecB.cbegin(), vecB.cend()};

PopulateSetDiff(vecA, setA, setB);
PopulateSetDiff(vecB, setB, setA);

// Populate 'vec' with 'set1 - set2'
template <typename T>
void PopulateSetDiff(
  vector<T>& vec,
  unordered_set<T> const& set1,
  unordered_set<T> const& set2) {
  vec.clear();
  for (const auto elem : set1) {
    if (set2.find(elem) == set2.cend()) {
      vec.push_back(elem);
    }
  }
  vec.shrink_to_fit();
}

Answer 3

不，我将通过sort（fileList.begin（），fileList.end（））来求助它们;之后

渐渐地，以前排序是一样的。

使用set_difference，您可以执行以下操作：

name-2

c ++：从另一个向量中删除一个向量中的元素

3 个答案: