Sortieren von double-Werten?!?

Hallo,

ich habe Probleme bei folgender Aufgabenstellung:

Gegeben sei ein zufällig gefülltes double feld mit 10 verschiedenen Zahlen.
Schreiben Sie eine Funktion, welche die drei größten double Werte des Feldes
ausgibt. Diese Funktion bekommt das entspr. Feld als Parameter zurückgegeben.

z.B: double feld[10] = {1.2, 5.1, 5.0, 11.9, 3.1415, 0.4, -12.7, 13.005, 9.99,
10.0};

führt zur Ausgabe der Zahlen: 13.005, 11.9, 10.0

Wie muss ich da vorgehen? Kann es sein, das dafür nur eine Funktion benötigt wird? Ich brauch doch eine die sortiert und eine die austauscht und dann noch überprüft.

Hoffe ihr könnt mir auf die Sprünge helfen!
DANKE!!!

Walli

Du brauchst doch nicht zu sortieren dafür. Laufe einmal durch das Array und speichere die 3 größten Elemente irgendwo.

Windalf

wie walli schon sagt brauchst du zwar nicht zu sortieren aber wenn du dir kein aufwand machen willst (und lieber den rechner arbeiten lässt ) ist der ansatz schon richtig... kannst std::sort (oder qsort) verwenden um dein array sortieren zu lassen und dann brauchst du nur noch die ersten drei elemente ausgeben und die sache ist gegessen...

enno-tyrant

irgendwie fällt mir da auf anhieb: www.volkard.de ein, schaus dir mal an (tip: bubble sort (von mir aus))

also das versteh ich jetzt nicht.

soweit bin ich mal:
const int arraySize = 10;
double a[ arraySize ] = {1.2, 5.1, 5.0, 11.9, 3.1415, 0.4, -12.7, 13.005, 9.99, 10.0};

und wie lauf ich da jetzt durch? Mit for-Schleife? Wenn ja wie sieht mein Argument aus damit ich die 3 größten Zahlen finde?

danke!

enno-tyrant

vergleiche die zahlen mit einander (bubble sort nutzt das prinzip)

ok dann werd ich mir mal den BubbleSort anschauen. Hört sich aber nicht so einfach an....

Balrog

Das ist jetzt sicherlich noch nicht die obergeile Lösung, aber ein Vorschlag:

/**
* @returns Liefert einen std::vector<double> mit den drei höchsten Werten
* aus feld[], Type double, zurück.
*/
std::vector<double> getHighestThree() const {

  double feld[] = {1.2, 5.1, 5.0, 11.9, 3.1415, 0.4, -12.7, 13.005, 9.99, 10.0};  
  const unsigned int n = sizeof(feld) / sizeof(double);	
  std::sort(feld, feld + n);

  std::vector<double> returnValues;
  for ( unsigned int idx = n; idx > 0 && idx > 7; idx-- ) {
   returnValues.push_back( feld[idx-1] );
  }
  return returnValues;
}

Gruß

H.-Gerd

http://www.brainsandbytes.de

dali

Lass Quicksort drüberlaufen und nimm die letzten 3 Elemente dann raus :

void Partition(int values[], int* i, int* j) {
    int pivot = values[(*i+*j)/2];
    int temp;

    while(*i <= *j) {
        while(values[*i]<pivot) {
           (*i)++;
        }
        while(values[*j] > pivot) {
            (*j)--;
        }
        if(*i <= *j) {
            temp = values[*i];
            values[*i] = values[*j];
            values[*j] = temp;

            (*i)++;
            (*j)--;
        }
    }
}

void QuickSort(int values[], int m, int n) {
    int i = m;
    int j = n;
    if(m < n) {
        Partition(values, &i, &j);
        QuickSort(values,m,j);
        QuickSort(values,i,n);
    }
}

Walli

Gut, dass es in der Standardlib noch keine Sortieralgos gibt. So hat wenigstens jeder seinen eigenen in der Schublade.

Ringding

Dafür gibt's partial_sort.