Question

我有两个数组，比如A = {1,2,3,4,5}，B = {5,6,3,4,5}。我想比较两个数组，并告诉A中有多少元素小于B，反之亦然，也可能是元素位置较小。我可以使用嵌套循环来做到这一点，但在C ++中有一种有效的方法吗？

在这个例子中， A = {1,2,3,4,5} B = {5,6,3,4,5}

所以我希望答案是“B大于A”只是因为它满足了两个元素中更大的条件。或者如果是

A = {1,2,3,4,5}且B = {1,2,3,0,4}，A更大。

如果元素大于或小，我只需要比较数字，而不是本身的值。

对不起我的含糊不清。

Answer 1

目前尚不清楚你的意思。你的意思是按元素比较它们吗？

vector<int> indexesForA;
vector<int> indexesForB;
for(int i = 0; i < length; i++) {
    if(A[i] < B[i]) {
        indexesForA.push_back(i);
    }
    else if(B[i] < A[i]) {
        indexesForB.push_back(i);
    }
}

// now indexesForA.size() is the count of indexes i where A[i] < B[i]
// and indexesForA contains the indexes
// similarly for indexesForB

请发表澄清，我们可以为您提供指导。

Answer 2

这是我的例子。也许它可以使用更先进的STL技术，但我认为这就足够了。

class Examiner
{
    template <class Pred>
    struct CompareToZero: std::unary_function<const int&, bool> {
        Pred comparator;
        bool operator() (const int& value) const {
            return comparator(value, 0);
        }
    };
    template<class T>
    std::vector<size_t> getComparedIndices(const CompareToZero<T>& comparator, const std::vector<int>& vint) const {
        std::vector<size_t> retval;
        for (size_t i = 0; i < vint.size(); i++) {
            if (comparator(vint[i]))
                retval.push_back(i);
        }
        return retval;
    }
    const std::vector<int>& _results;

public:
    Examiner(const std::vector<int>& results)
        : _results(results) {
    }

    std::vector<size_t> getLessIndices() const {        
        return getComparedIndices(CompareToZero<std::less<int> >(), _results);
    }
    std::vector<size_t> getGreaterIndices() const {
        return getComparedIndices(CompareToZero<std::greater<int> >(), _results);
    }
    std::vector<size_t> getEqualIndices() const {
        return getComparedIndices(CompareToZero<std::equal_to<int> >(), _results);
    }
    size_t getLessCount() const {
        return getLessIndices().size();
    }
    size_t getGreaterCount() const {
        return getGreaterIndices().size();
    }
    size_t getEqualCount() const {
        return getEqualIndices().size();
    }
};


void arrcomp()
{
    int A[5] = {1,2,3,4,5};
    int B[5] = {5,6,3,2,4};

    std::vector<int> results(sizeof(A)/sizeof(A[0]));
    for (size_t i = 0; i < results.size(); ++i) {
        results[i] =
            (A[i] < B[i])? -1:
                (A[i] > B[i])? 0:
                    1;            
    }
    Examiner examiner(results);

    std::cout << "less count   : " << examiner.getLessCount() << std::endl;
    std::cout << "greater count: " << examiner.getGreaterCount() << std::endl;
    std::cout << "equal count  : " << examiner.getEqualCount() << std::endl;    
}

Answer 3

你想比较A和B的相应元素并计算A'小于匹配B的数量吗？这可以通过std :: inner_product完成，如下所示：

int A[] = { 1,2,3,4,5 };
int B[] = { 5,6,3,4,5 };

int count = std::inner_product(A, A+5, B, 0, std::plus<int>(), std::less<int>());

std::cout << count << "\n";

当然，这只是STL数值算法中的O（n）循环。

Answer 4

int A[5] = {1,2,3,4,5};
int B[5] = {5,6,3,2,4};

std::vector<int> vectA(A);
std::vector<int> vectB(B);

并使用std <algorithm>在两个向量上完成工作或部分工作。

例如： count_if返回满足条件的范围内的元素数（函数模板）

Answer 5

你是什么意思？你的意思是A [i]＆lt; B [i]或者你的意思是B中有多少元素小于A [i]？要么你有一个循环来比较每个数组的第i个元素，要么你将有一个嵌套循环，你将A的第i个元素与B的第j个元素进行比较。因为我没有知道你想要哪一个，我不能告诉你正确的答案。

Answer 6

我认为最有效的方法是首先对数组进行排序，然后检查哪个索引是数组B的第一个元素，它大于它的A对应元素。由于排序是可传递的，您甚至可以对同一遍中的所有元素执行此操作。

比较两个数组

6 个答案: