effizienter C-Code zum Vergleichen von 6 Werten

hm, 8bit unsigned - was braucht man da über den Rechenaufwand 
nachdenken?

Das ganze sollte halt möglichst schnell abgearbeitet werden. (ca. 10us 
bei einem Takt von 16Mhz im ATMega168)

Ich komme grade auf keinen sauberen Code, nur auf etliche if-Abfragen 
und Vergleichsoperationen.

Hallo,
wer n Zahlen auf die grösste untersuchen will muss nun mal alle in die 
Hand nehmen! Das ist doch offensichtlich!

>for a=2 to 6 if wert[a]>zielwert dann zielwert=wert[a] und break

ohne break geht's besser,
immer genau 5 Vergleiche

max(a1,max(a2,max(a3,max(a4,...,max(an-1,an)...)

zielindex=1
for a=2 to 6 if wert[a]>wert[zielindex] dann zielindex=a

Jochen Müller schrieb:

> <pseudocode>
> zielwert=wert[1]
> for a=2 to 6 if wert[a]>zielwert dann zielwert=wert[a] und break
> </pseudocode>

Der break ist zuviel, sonst stimmts.

Wenn es noch etwas schneller gehen soll, oder wenn die sechs Zahlen
nicht in einem Array vorliegen, kann man die Schleife natürlich auch
auseinanderrollen, so dass 5 If-Anweisungen dastehen. Das dürfte dann
etwa 16 Zyklen, also 1 µs dauern.

Geht für Arrays der Länge 2(!)-255

byte i=sizeof(array)/sizeof(array[0])-1; //Länge des Arrays -1
max=array[0];

do {
if (max<array[i] max=array[i];
} while (--i); //dekrement und anschließendes prüfen auf 0
               //erzeugt am wenigsten "overhead"

//in max steht das maximum

Also,

Quicksort wäre sicherlich eine gute Lösung

Also es ist so:

Ich habe einen Aray, werte[a;b;c;d;e;f].
Nun will ich die Stelle herauskriegen, an welcher der größte Wert steht. 
Dessen Betrag ist egal.

Grüße

Ok,
so sollte es recht zügig funktionieren:

void CompIndukt(void)
{

  extern uint16_t werte[];
  extern uint8_t max;
  uint8_t index=0;
  uint16_t store=werte[0];

  for (index=0;index<6;index++)
  {

         if(werte[index]>store)
    {
    store=werte[index];
    max=index;
    }
  }

}

max gibt dann die Position der Größten Zahl im Aray an.

Wie wäre es damit:

1

byte i=5;

2

byte max=5;

3

4

do {

5

   if (werte[max] < werte[i-1]) {

6

      max = i-1;

7

   }

8

} while (--i);

Nach Durchlauf steht max auf den Index des Array-Elements mit dem 
größten Wert.

Gruß
Christoph