C++：检查所有数组元素是否相等的最快方法

Question

What is the fastest method to check if all elements of an array(preferable integer array) are equal. Till now I have been using the following code:

bool check(int array[], int n)
{   
    bool flag = 0;

    for(int i = 0; i < n - 1; i++)      
    {         
        if(array[i] != array[i + 1])
            flag = 1;
    }

    return flag;
}

Answer 1

int check(const int a[], int n)
{   
    while(--n>0 && a[n]==a[0]);
    return n!=0;
}

Answer 2

Here is a solid solution which is valid C++11. The advantages is that you do not need to manually play with the indexes or iterators. It is a best practice to

prefer algorithm calls to handwritten loops [Herb Sutter - C++ Coding Standards]

I think this will equally efficient as Paul R's solution.

bool check(const int a[], int n)
{
      return !std::all_of(a, a+n, [a](int x){ return x==a[0]; });
}

Answer 3

Once you have found a mismatching element you can break out of the loop:

bool check(const int array[], int n)
{   
    for (int i = 0; i < n - 1; i++)      
    {         
        if (array[i] != array[i + 1])
            return true;
    }
    return false;
}

If this is performance-critical then it can be further optimised slightly as:

bool check(const int array[], int n)
{   
    const int a0 = array[0];

    for (int i = 1; i < n; i++)      
    {         
        if (array[i] != a0)
            return true;
    }
    return false;
}

Answer 4

Recast the array to a larger data type. Eg, operate on 64bit ints, or use SSE or AVX intrinsics for 128 or 256 bit operation. For example, the SSE2 intrinsic is _mm_cmpeq_epi32, whose result you'll use with _mm_or_si128. Check the result with repeated application of _mm_srli_si128 and _mm_cvtsi128_si32. Check the result every few hundred iterations for early exit.

Make sure to operate on aligned memory, check the unaligned start and end as ints, and check the first packed element with itself.

Answer 5

We'll it's basically an O(n) operation so you can't do much better than what you have, other than dispensing with the flag and just return false; on the first failure and return true; after the iteration.

Answer 6

bool check(int array[],int n)
{       
  // here 1st element is checked with others. This decreases the number of iteration by 1.
  // also it returns immediately. 
  // The requirement is to check if all the elements are equal. 
  // So if 1st element is equal to others then all elements are equal. 
  // Otherwise the  elements are not equal.
  for(int i=1;i<n;i++)      
  {         
    if(array[0]!=array[i])
      return false;
  }        
  return true;
}

Answer 7

Find a library that's available on your platform that supports threading or parallel-for loops, and split the computation out such that different cores test different ranges of the array.

Some available libraries are listed here:

http://parallel-for.sourceforge.net/parallelfor.html

Or possibly, you can make use of the parallism that many GPU's offer.

Answer 8

In theory, I would propose this:

bool check_single(const int a[], int n)
{
    for (int i = 1; i < n; ++i) {
        if (a[0] != a[n]) { return false; }
    }
    return true;
}

Compared to other (already proposed) versions:

• a[0] will be hoisted outside the loop by the compiler, meaning a single array access within the loop
• we loop from 0 to n, which is better (access-wise) than loading a[0] and then looping from a[n]

Obviously, it still checks N elements and thus is O(N).

Answer 9

For programmer efficiency you may try the following all in one line.

vector<int> v{1, 1, 1, 1};
all_of(v.cbegin(), v.cend(), [&r=v[0]](int value){ return value == r; }->bool);

I did not test run this code, let me know if there is syntax error.

Answer 10

fast hash mapping technique:

bool areSame(int a[],int n)
{
    unordered_map<int,int> m; //hash map to store the frequency od every

    for(int i=0;i<n;i++)
       m[a[i]]++;
      
    if(m.size()==1)
       return true;
    else
       return false;
}

Answer 11

I think the following is more readable than the highest rated answer and I would wager more efficient too (but havent benchmarked)

bool check(int a[], int n)
{   
    if (n)
    {
        auto first = a[0];
        
        for(int i = 1; i < n; i++)      
        {         
            if(array[i] != first) return false;
        }
        
        return true;
    }

    return true;    //change to false for the OPs logic.  I prefer logical true here
}

Answer 12

bool check_identity (int a[], int b[], const int size)
{
    int i;
    i = 0;
    while ((i < size-1) && (a[i] == b[i]))   i++;

    return (a[i] == b[i]);

}