通过块比较两个向量时，如何避免重复

How to avoid repetitions when comparing two vectors by blocks

本文关键字：向量 何避免 两个 比较      更新时间：2023-10-16

我正在尝试比较两个大小为4的大小的向量，并且数据用块(4个元素(表示。每个向量块都有一个唯一的数字，例如{0,0,0,0}，{0,0,0,1}，{0,0,0,0,2}或{0,0,0,0,0,0，0,0,1,0,0,0,2}和{0,0,0,2,0,0,0,1}等等。我正在使用迭代器，每次都会增加I = 4。我写了一个小功能，可以完成工作，但块倾向于重复。我不确定T0如何删除这些块的重复。例如vector_a {0,0,0,0,0,0,0,1} vector_b {0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,2}0,0,0,2}相反，我获得了本地vector_1 {0,0,0,1,0,0,0,0,2,0,0,0,0,0,0,0,0,0,2} 

void comparing_vectors_by_block(std::vector<int> vector_A, std::vector<int> 
vector_B)
{
const int blockSize = 4;
std::vector<int> local_vector1;
std::cout << "size of the vector_A: " << vector_A.size() << std::endl;
std::cout << "size of the vector_B: " << vector_B.size() << std::endl;
for (auto it_A = std::begin(vector_A); it_A != std::end(vector_A); it_A+=4)
{
    for (auto it_B = std::begin(vector_B); it_B != std::end(vector_B); it_B += 4)
    {
        bool match = equal(it_A, it_A + blockSize, it_B, it_B + blockSize);
        if (!match)
        {
            std::cout << "match :" << std::endl;
            local_vector1.insert(local_vector1.end(), it_B, it_B + blockSize);
        }
        else
        {
            std::cout << "not matched :" << std::endl;
        }
    }
}

使用四个int的数组的向量来表示数据。 std::vector<std::array<int,4>> vect1;

如果此数据还有其他含义。最好使用OOP并创建一个结构或类代表四个数字数据。然后实现运算符==和其他有用的结构/类方法。

struct foo{
    int a;
    int b;
    int c;
    ind d;
};
bool foo::operator==(const X& lhs, const X& rhs){ /* do actual comparison */ }

然后仅迭代向量并使用==比较元素，例如，如果向量为int类型。

。 
for(auto& x : vector_A)
{
    if(std::find(vector_B.begin(), vector_B.end(), x) != vector_B.end()) {
         local_vector1.append(x);
    }
}

如果我把你弄对了，您想获得两个块向量的对称差异。IE。对于a = {0,0,0,0,3,0,0,0,0,0,0,0,1}和b = {0,0,0,0,1,0,0,0,0,0,0，0,0,2}您想要Local_Vector1 = {0,0,0,3,0,0,0,2}。

在实施中，您将向量A的每个块与向量B的每个块进行比较 - 当然，您会获得额外的不匹配。我的(也不优化的(解决方案：

std::vector<int> get_blocked_vectors_diff( const std::vector<int>& vector_A, const std::vector<int>& vector_B )
{
    const int blockSize = 4;
    std::vector<int> local_vector;
    for ( auto it_A = std::begin( vector_A ); it_A != std::end( vector_A ); it_A += 4 )
    {
        bool found_in_B = false;
        for ( auto it_B = std::begin( vector_B ); !found_in_B && it_B != std::end( vector_B ); it_B += 4 )
        {
            found_in_B = std::equal( it_A, it_A + blockSize, it_B, it_B + blockSize );
        }
        if ( !found_in_B )
        {
            local_vector.insert( local_vector.end( ), it_A, it_A + blockSize );
        }
    }
    return local_vector;
}
void comparing_vectors_by_block(std::vector<int> vector_A, std::vector<int> vector_B)
{
    auto A_mines_B = get_blocked_vectors_diff( vector_A, vector_B );
    auto B_mines_A = get_blocked_vectors_diff( vector_B, vector_A );
    auto local_vector1( A_mines_B );
    local_vector1.insert( local_vector1.end(), B_mines_A.begin( ), B_mines_A.end( ) );
    for ( auto a : local_vector1 )
    {
         std::cout << a << " ";
    }
    std::cout << std::endl;
}

请注意，我们需要答案的两个部分：

如果您像Petar Velev建议更改数据结构，则可以缩短get_blocked_vectors_diff函数：

std::vector<int> get_blocked_vectors_diff( const std::vector<Block>& vector_A, const std::vector<Block>& vector_B )
{
    std::vector<Block> local_vector;
    for ( auto& x : vector_A )
    {
        if ( std::find( vector_B.begin( ), vector_B.end( ), x ) == vector_B.end( ) )
        {
            local_vector.push_back( x );
        }
    }
    return local_vector;
}

如果您先对块的向量进行排序，则可以获得更好的解决方案。

相关文章：