Hallo,

mein Programm zieht sich ein paar Zufallszahlen und sotiert diese auch.

Wie ich kann ich nun die Anzahl der Durchgänge ausgeben ?

danke schonmal

# include <iostream.h>

# include <conio.h>

# include <stdio.h>

# include <math.h>


main()

{

int i,k,c,f,zahlenhaufen[10],zwischen;


/*Eingabe*/


randomize();

for (i=0;i<10;i++)

{

   zahlenhaufen[i]=random(500)+1     ;

}




/*Verarbeitung*/


for (k=1;k<10;k=k+1)

{

for (c=1;c<=(10-k);c=c+1)

{

if (zahlenhaufen[c] > zahlenhaufen[c+1])

{

zwischen = zahlenhaufen[c];

zahlenhaufen[c] = zahlenhaufen[c+1];

zahlenhaufen[c+1] = zwischen;

}

}

}


/*Ausgabe*/

for (f=1;f<10;f=f+1)

{

cout<<"\n"<<zahlenhaufen[f]<<"\n";

}

/*No comment*/

getch();

}

Was meinst du mit "Durchgänge"? Anzahl der Vergleiche? Anzahl der Vertauschungen?

In jedem Fall musst du eine Zählvariable deklarieren, mit 0 initialisieren und dann an der Stelle im Code, an der das passiert, was du zählen möchtest, um 1 erhöhen.

Anzahl der Vertauschungen .. .

hab in die IF Anweisung

tauschen=tauschen+1; ( voher deklariert )

und es dementsprechnend ausgegeben und es Funktioniert

danke für deine Antwort

hab in die IF Anweisung

tauschen=tauschen+1; ( voher deklariert )

und es dementsprechnend ausgegeben und es Funktioniert

Das ist richtig, es geht aber noch kürzer, und sieht nicht so aus wie BASIC

++tauschen;

Das ist richtig, es geht aber noch kürzer, und sieht nicht so aus wie BASIC

++tauschen;

Frage am Rande:

Gibts Performanceunterschiede zwischen Pre- und Postinkrement?

Ich mach aus Gewohnheit eigentlich immer Postinkrement.

(Das der Zuweisungs-/Erhöhungsunterschied ist mir bekannt, dennoch würd's mich interessieren.)

Frage am Rande:

Gibts Performanceunterschiede zwischen Pre- und Postinkrement?

In diesem Fall vermutlich nicht.

Ich mach aus Gewohnheit eigentlich immer Postinkrement.

(Das der Zuweisungs-/Erhöhungsunterschied ist mir bekannt, dennoch würd's mich interessieren.)

Mach lieber Präinkrement, wenn's egal ist. Der besondere Nebeneffekt des Postinkrement (nämlich dass der ganze Ausdruck den "alten" Wert hat), kann Performance kosten, wenn es kein triviales Objekt ist, das inkrementiert wird.

So könnte man sich z.B. einen komplexen Iterator vorstellen: Präinkrement ist da ziemlich einfach umzusetzen, beim Postinkrement muss allerdings der Operator eine Kopie des Iterator-Objekts erstellen, damit er den "alten" Wert zurückgeben kann.

Wenn der Rückgabewert des Operators wie hier gar nicht verwendet wird, sollte ein moderner Compiler das optimieren können. Aber ich finde, man sollte sich gleich angewöhnen, die Variante zu benutzen, die in den wenigen Fällen, wo es dann doch drauf ankommt, die bessere ist. Postinkrement benutze ich nur dann, wenn ich den speziellen Seiteneffekt wirklich brauche.