array highest value

RickyD77

ok i have an array whit 10 value in i just want to retreive the array number of the highest value

thx Eric

ir4z0r

either run a loop and compare the values or sort it and take the first/last one

Arc

There is no built in function to do this, but here is one i wrote that does what you need.

Function GetHighestArrayValue($Array){
  For($Counter=0; $Counter<count($Array); $Counter++){
   If($Array[$Counter] > $Value)$Value = $Array[$Counter];
  }
return $Value;
}

To use it just make sure this function is on the page yer using then for example do this..

$Myarray[0]=23;
$Myarray[1]=32;
$Myarray[2]=780;
$Myarray[3]=45;
$Myarray[4]=67;

Print GetHighestArrayValue($Myarray);

Arc

It would be alot faster though if you kept a global variable that checked each item as it was added to the array and then updated if the value was greater than the one already there. This way you wouldn't have to loop thru an entire array.

But if your array isn't too large it shouldn't be a problem either way.😃

RickyD77

thx alot

BuzzLY

$highval = array_pop ( sort ( $array ));

That should work, shouldn't it? No need to loop through array. Looping is fine, of course, but if you had 100,000 elements instead of 10, the above code would be much faster, I would think. Unless the sort algorithm of PHP sucks, that is... never tested it before...

Weedpacket

If depends on what the data is of course, but the index of the highest value isn't necessarily unique.

If any suitable index will do

array_search(max($array))

If you want all of them:

array_keys($array, max($array))

laserlight

um, BuzzLY, sorting definitely involves some looping, and even if quick sort or something is used on a large array, a sequential search will be much faster than sorting then picking off the last value in the sorted array.

Weedpacket's examples probably are the ones to use since seaching with a loop in PHP may just be slower than using some function already declared in PHP itself.

BuzzLY

Yeah, you are right, laserlight. I wasn't really thinking clearly, and a sort's loop (even a quicksort) would take longer, even when done within the PHP "kernel."

I do know how search algorithms work. My hope is that PHP uses something better than a bubble sort in it's sort() function (which, incidentally, IS a built-in function of PHP -- hence my confusion at your comment). I'm sure they use quicksort, as it seems to be the favorite sort (there are faster sort algorithms, of course).

I also made the assumption that in this particular case, the array was sequential, not associative. I probably shouldn't have made such an assumption, or at least clarified that my solution would only work in that case. I was going for a solution that was short, not necessarily the fastest. I had forgotten that max() can be used on an array.

Weedpacket's solution is definitely the way to go, and is also probably the fastest -- depending on the algorithm max() uses. It's probably a simple loop through the array values similar to Arc's solution. A timing test would verify which was the best, but it may be overkill in this case. My guess is that Ricky simply needs a method for finding the maximum value, and is not really concerned about speed (especially for a 10 item array).

If anything, this is a clear illustration that in any language, there are many different ways to accomplish the same goal. Some are faster, some require less coding, but in the end if it gives you the solution you want, and is fast enough, then it's the "right" answer.

Ricky, I hope we answered your question sufficiently, and didn't overkill it 😃

BuzzLY

I timed how long it would take to use each method (manually written PHP script, sort(), and max() ), and it looks like max() is the clear winner.

Remember, of course, that sort() and max() perform very different functions. max() is very utilitarian -- it simply returns the maximum value in the array. sort() performs, well, a sort on the ENTIRE array. Considering this, I was quite impressed to see that sort() was able to crunch through 500,000 values (that's half a million!) in just under 6 seconds. max() returned the maximum value in less than a quarter second, and the manual script returned the same value in 1.6 seconds.

If anyone else would like to do the test themselves, or see the script I used to test this, I have attached it. Make sure you rename it with a .php extension before loading it up in your browser.

laserlight

Well, nothing new, that was the expected results.

Of course the actual values will differ on the same machine given the same resources since the data used will vary if they are randomly or pseudo-randomly generated.

BuzzLY

Yes, laserlight, they were the expected results. For some. 🙂

However, the person posting the original question might not have known which was the best to use. And of course, there may be plenty of people lurking that also needed to know the information.

You seem quite intelligent, and I have no doubt that much of this thread is rehashing information that you already know. Many people using this board are PHP newbies, and may learn something from this thread -- after all, that's why it's called "General Help."

I decided to do a little research on the matter, to find out just how much faster each method was. What mattered was not the actual times, but the DIFFERENCE in times between each method. When I was done, I thought I would share my findings with the group. Nothing wrong with that, is there?

What I actually discovered was that although max() is the best method, it really doesn't matter which you use if your data set is relatively small (like 10,000 or less). The sort routine may have taken the longest, but it would still be very quick, and may have some use for some people.

Arc

Let's not forget that fastest method which is instant 0.0 seconds..

It would be alot faster though if you kept a global variable that checked each item as it was added to the array and then updated if the value was greater than the one already there.😃

This way to get the highst value in the array you simply need to call the Variable holding the already determined highest array value.

But if you have no control over adding the items to the array then this wouldn't be possbile 🙂

I learned a lot in this thread 🙂

laserlight

That method would be good, but the given question was with an existing array of 10 elements, so the suggestion would have to be "compare values while filling in the array" instead.

It isnt done in an instant though, but comes close 😃

BuzzLY

Not a bad suggestion, of course, but arrays are not always "built." If the array was created by pulling values from a database (a strong possibility), then that's not an option. For a 10-item array, really any of the options presented would work. Even the sort takes no time. Here are the results of running my script on only 10 array items:

Timing test to find maximum value in an array
using manually written PHP script, sort(), and max()

Start: 0.000 0.000
Array Created: 0.000 0.000
PHP Loop method:: 0.000 0.000
sort() method:: 0.000 0.000
max() method:: 0.000 0.000

Elapsed time: 0.000

Once again, expected results, right? 🙂 In this case, I would ALWAYS use sort -- you never know when I might need to access values from the sorted array.

Ricky, I hope you are not sorry you asked this question. Sometimes the simplest questions will spark the most interesting debates. This is an excellent example of different developers preferring different methods to accomplish the same goal.

Sxooter

Originally posted by Arc
Let's not forget that fastest method which is instant 0.0 seconds..

This way to get the highst value in the array you simply need to call the Variable holding the already determined highest array value.

But if you have no control over adding the items to the array then this wouldn't be possbile 🙂

I learned a lot in this thread 🙂

But you're just moving the effort of the max() function into the array maintenance. The retrieval is faster but the setup is slower. if you're building a 100,000 element array, it would have to be cheaper to use max() after it's built than to update a $max varialbe ~ 50,000 times.