ich möchte 3 Integer Werte der Größe nach sortieren:
Hier ist ein teil meines Programms. Dieser Sortiert die erste Zahl an die richtige Stelle:

cout << "Bitte gib drei Integer Werte ein: \n";
int wert1 = 0;
int wert2 = 0;
int wert3 = 0;
int count1 = 0;
int count2 = 0;
int count3 = 0;
cin >> wert1 >> wert2 >> wert3;
//Wert1
if ((wert1 < wert2) && (wert1 < wert3))
count1 = wert1;
if ((wert1 < wert2) && (wert1 > wert3))
count2 = wert1;
if ((wert1 > wert2) && (wert1 < wert3))
count2 = wert1;
if ((wert1 > wert2) && (wert1 > wert3))
count3 = wert1;
cout << "\n1. " << count1;
cout << "\n2. " << count2;
cout << "\n3. " << count3;

Kann man das eleganter lösen ??
Bei 3 Werten wird es ja schon unübersichtlich wie wird es dann erst mit 5 oder mehr Werten.
Ich wollte es am Anfang eigentlich mit einer While Anweisung prüfen und abarbeiten lassen also in einer Schleife das funktioniert aber nicht da die Abhängigkeit dann immer nur von einem Wert betrachtet wird.

Danke

z.B mit Bubblesort

Das ist sicherlich die uneleganteste Möglichkeit .

Allgemein gibt es schon std::sort in der Standardbibliothek. Wenn du wirklich nur drei Werte hast und du sicher bist, dass es immer nur drei Werte sein können, dann kannst du dir auch überlegen, wie man diese mit ifs und swaps optimal sortieren kann. Das haben aber schon andere Leute gemacht:
http://en.wikipedia.org/wiki/Sorting_network

Für n=3 kann man dann finden:

o-----^--^--o
      |  |   
o--^--|--v--o
   |  |      
o--v--v-----o

There are 3 comparators in this network,
grouped into 3 parallel operations.

[[1,2]]
[[0,2]]
[[0,1]]

This is graphed in 3 columns.

Das heißt in Code (ungetestet):

#include <algorithm> // für swap, schreib dir zur Not ein eigenes swap, wenn du die Standardbibliothek nicht nutzen willst

// ...

 if (wert2 < wert1) swap(wert1, wert2);
 if (wert2 < wert0) swap(wert0, wert2);
 if (wert1 < wert0) swap(wert0, wert1);

Die Werte sind nun mit minimalem Aufwand garantiert sortiert. Für 5 ist das auch noch ok, vielleicht sogar bis in niedrige zweistellige Bereiche (man kann sich den Code auch automatisch erzeugen lassen). Für größere Zahlenmengen oder Zahlenmengen unbekannter Größe solltest du aber wirklich die Standardbibliothek benutzen oder, als Masochist, deine eigene Sortierfunktion schreiben (aber nicht Bubblesort! Quicksort oder Mergesort sind auch nicht schwer, dafür aber effizient!). Für beides musst du deine wert1, wert2, wert3,... aufgeben und die Werte irgendwie adressierbar speichern, z.B. in einem vector.

There are 3 comparators in this network,
grouped into 3 parallel operations.

Nein, es sind 3 sequentielle Operationen.

Zusatz, fuer Inputs bis 24:
Slides: http://www.genetic-programming.org/hc2011/03-Valsalam/Valsalam-Slides.pdf
Arbeit: http://www.genetic-programming.org/hc2011/03-Valsalam/Valsalam-Paper.pdf

There are 3 comparators in this network,
grouped into 3 parallel operations.

Nein, es sind 3 sequentielle Operationen.

Das ist schon so gemeint. Das sind drei sequentielle Blöcke mit jeweils einer "parallelen" Operation. Bei n=4 stünde auf der Seite wo ich das her habe:

o--^--^--------o
   |  |         
o--v--|--^--^--o
      |  |  |   
o--^--v--|--v--o
   |     |      
o--v-----v-----o

There are 5 comparators in this network,
grouped into 3 parallel operations.

[[0,1],[2,3]]
[[0,2],[1,3]]
[[1,2]]

This is graphed in 4 columns.

Jetzt klar?

Hmm, ich weiss nicht. Also parallel kann man nur die Vergleiche in einer Zeile ausfuehren. Aber vielleicht kannst du ja die Seite nennen? Ok, parallel bezieht sich wahrscheinlich nicht auf die Ausfuehrung.

Hier:
http://pages.ripco.net/~jgamble/nw.html

Das ist praktisch so gemeint, wieviele Schritte man mindestens braucht, selbst wenn man perfekt parallelisiert.

Danke !!