Easiest way to find the max value stored in an array

What is the easiest way to find the maximum value stored in an array and display it on the screen...
Here's what I worked out, don't know if it works, because I don't have a compiler installed on this computer...

Code:

#include <iostream>
using namespace std;

void MaxElement (int Array [], int& Max);

const int ArraySize = 3;

int main (void)
{
   int max;
   int Array [3]; 

   
	Array [0] = 102;
	Array [1] = 230;
	Array [2] = 191;
	max = Array [0];
    MaxElement (Array, max);
    cout << "Max Value: " << max << endl;
    return 0;
}

void MaxElement (int Array [], int& max)
{
	    for (int i = 1; i < ArraySize; i ++)
   {
      if (Array [i] > max)
         max = Array [i];
   }
}

> for (i = 0; i < ArraySize; i ++)

Slightly faster is:
for (i = 1; i < ArraySize; i++)

usually I set max to -32000 and walk through every array element... even though the way you have it is probably faster... although I don't think that speed is really a big factor in this situation...

Originally posted by major_small
usually I set max to -32000 and walk through every array element... even though the way you have it is probably faster... although I don't think that speed is really a big factor in this situation...

And what if the max int in your list is -33000?

maybe it would be better to pass the array size, and return the maximum value instead:

Code:

#include <iostream>
using namespace std;

int MaxElement(int Array[], int array_size);

int main()
{
	const int array_size = 3;
	int Array[array_size];

	Array [0] = 102;
	Array [1] = 230;
	Array [2] = 191;

	cout << "Max Value: " << MaxElement(Array, array_size); << endl;
	return 0;
}

int MaxElement(int Array[], int array_size)
{
	int max = Array[0];
	for (int i = 1; i < array_size; i++)
	{
		if (Array[i] > max)
			max = Array[i];
	}
	return max;
}

Originally posted by swoopy
And what if the max int in your list is -33000?

The trick there is that the minimum value that can be stored in a signed short int is greater than -33000. If you tried to store that value in a short, you'd have an overflow error.

Originally posted by laserlight
maybe it would be better to pass the array size, and return the maximum value instead:

Code:

#include <iostream>
using namespace std;

int MaxElement(int Array[], int array_size);

const int array_Size = 3;

int main()
{
	const int array_size = 3;
	int Array[array_size];

	Array [0] = 102;
	Array [1] = 230;
	Array [2] = 191;

	cout << "Max Value: " << MaxElement(Array, array_size); << endl;
	return 0;
}

int MaxElement(int Array[], int array_size)
{
	int max = Array[0];
	for (int i = 1; i < array_size; i++)
	{
		if (Array[i] > max)
			max = Array[i];
	}
	return max;
}

Why would you define array_Size as a const, and then array_size as a const with the same value, and not even use array_Size? It adds unnecessary complexity. Using a global constant eliminates having to pass it from the main to the function, and eliminates alot of typing...

Presumably you might need to use array_size in main() at some later point (when dealing with the array), and so you could re-use that.

If you need to change the size of the array, then you just need to change array_size and modify the array declaration.

At the same time, not using a global variable means that MaxElement() is not tied to that particular program.
Maybe you decide to place various functions into header files, and include them.

If you then decide to use this header file in some other program, you dont have to use the same variable names etc, but just need to pass the variable as an argument to the function.

hmm... my apologies there too, I didnt see that I neglected to remove your own global variable declaration when modifying your code.

Anyway, typing more does not necessarily add to complexity.
For example, we could then use:

Code:

#include <iostream>
using namespace std;

int main()
{
	const int array_size = 3;
	int Array[array_size];

	Array [0] = 102;
	Array [1] = 230;
	Array [2] = 191;

	int max = Array[0];
	for (int i = 1; i < array_size; i++)
	{
		if (Array[i] > max)
			max = Array[i];
	}

	cout << "Max Value: " << MaxElement(Array, array_size); << endl;
	return 0;
}

which actually is as complex in algorithmic terms as when a function is used, since it is the same algorithm.

Originally posted by joshdick
The trick there is that the minimum value that can be stored in a signed short int is greater than -33000. If you tried to store that value in a short, you'd have an overflow error.

Are you sure it's a short? It looks like an plain int to me.

> usually I set max to -32000 and walk through every array element
Whereas the OP did the right thing and set max to array[0] and walked the array.

There is no reason to set the initial max value low like that. Just assign it the value of the first element (the OP actually did this). Giving it a signed type limits the upper ranges by half, so unless you're really needing signed data, it's just doesn't make sense to do it that way. Actually, the cononical way to do it would be to return a pointer to the max element:

Code:

template <class t_type>
 t_type * maxptr(t_type data[], unsigned size)
{
 t_type * ret = data; 

     for(t_type * end = data+size; data != end; ++data)  {

         if(*data > *ret)  {
          ret = data;
       } 
    } 
 return ret;
}

Which you would then use to return a value:

Code:

template <class t_type>
 t_type max(t_type data[], unsigned size)
{
 return *maxptr(data, size);
}

or change a value:

Code:

template <class t_type>
 void hipassfilter(t_type data[], unsigned size, t_type ceiling)
{
    for(type_t * smp = maxptr(data, size); *smp > ceiling; smp = maxptr(data, size))  {
     *smp = ceiling;
   }
}

Originally posted by criticalerror
What is the easiest way to find the maximum value stored in an array and display it on the screen...

Well, as you're clearly using C++, why not just use max_element from <algorithm>? That would appear to me to be the easiest way:

Code:

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    int myArray[10] = {1,27,99,3,15,28,50,62,0,88};
    cout << *max_element(myArray, myArray+10) << endl;
}

Or, don't use an array. Store everything in a set or multiset. Largest element (using default sorting) at any given time will always be *(--setname.end()), certainly an easy way to deal with this issue.

Originally posted by Omnius
Well, as you're clearly using C++, why not just use max_element from <algorithm>? That would appear to me to be the easiest way:

Code:

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    int myArray[10] = {1,27,99,3,15,28,50,62,0,88};
    cout << *max_element(myArray, myArray+10) << endl;
}

Ah, nice, I didn't know that function already existed. That is extremely useful. Thanks.