3. Sortierfunktion.... wie geht das ?!

Sortierfunktion.... wie geht das ?!

  • ?

    hallo leute.... hab ein kleines problem.... und zwar das untere programm was ich hier geschrieben habe.... wurde vom dozenten ein wenig geändert.... (das dick geschriebene) was ich nochmal unten rausgeholt habe....

    mein problem ist.... das programm soll ja verschiedene zahlen die man eingibt sortieren von klein nach gross.... nun hat der dozent das dick geschriebene eine zeile versetzt unter das if (p_max > 0 ) dann hat er es richtig soertiert ...

    nun die frage wieso ?! ist das so ? wenn das dick geschriebene vor dem if (p_max > 0 ) ist soritiert er gross nach klein und wenn das dick geschriebene hinter if (p_max > 0 ) ist sortiert er es von klein nach goss.... könnte mir jemand ne antw. dazu schreiben ist ziiemlich driegend..... 😃

    danke für eure hilfe....

    # include <iostream>
using namespace std;

void main()  
{
	int vektorHugo[50], i, max;

	void func_sort(int[],int); //Funktionsprototyp----welche werte und in welcher reihenfolge die werte übergeben werden

	cout<< "Geben sie die anzahl an werten ein (max 50):";
	cin >> max;

	for(i=0; i<max; i++)
	{   
		cout<<endl;
		cout<< "Geben sie die zu sortierende Zahl ein:";//Einlesen der Zahlen in Vektor
        cin >> vektorHugo[i];

	}

	func_sort(vektorHugo,max);

	cout << endl;
}

void func_sort(int p_vektorHugo[50], int p_max)
{
	int Temp = 0,Zaehler;

	//1. Es wird das Maximum der aktuellen Reihe gesucht.
    int vergleich = 0;

	for ( Zaehler = 0; Zaehler < p_max; Zaehler++ )
	{
		if( p_vektorHugo[vergleich]<p_vektorHugo[Zaehler]) {
			vergleich = Zaehler;
		}
	}

	//2. Das gefundene Maximum wird mit dem jeweils letzten Wert der aktuellen Reihe vertauscht.
    Temp = p_vektorHugo[p_max-1];//erklärung:block
	p_vektorHugo[p_max-1] = p_vektorHugo[vergleich];
	p_vektorHugo[vergleich] = Temp;

	//3. Die aktuelle Reihe wird um den letzten Wert verkürzt.
	p_max--; //Kürzen des Vektors

	if (p_max > 0 )//rekursivbedingung(f,ruft sich selbst solange auf bis reihe nicht mehr kürzbar ist)
	func_sort(p_vektorHugo, p_max);
	cout << p_vektorHugo[p_max] << "\t";
}

    func_sort(p_vektorHugo, p_max);
    cout << p_vektorHugo[p_max] << "\t";

    0
  • ?

    Der sortiert immer von klein nach groß, nur unterscheidet sich die Reihenfolge der Ausgaben je nachdem, wo du das "cout<<..." hinsetzt.

    sort_1(v,n)
{
  //finde Maximum und setze es ans Ende

  n--;
  cout<<v[n];          //gibt aktuell größten Wert aus
  if(n>0) sort_1(v,n); //sortiert Restliste
}
-> Werte werden rückwärts ausgegeben

sort_1(v,n)
{
  //finde Maximum und setze es ans Ende

  n--;
  if(n>0) sort_1(v,n); //sortiert Restliste
  cout<<v[n];          //gibt aktuell größten Wert aus
}
-> Werte werden vorwärts ausgegeben
    0
  • ?

    versteh ich nicht....

    das mit dem sortieren verstehe ich.... aber ich verstehe nur nicht wenn ich das
    func_sort(p_vektorHugo, p_max);
    cout << p_vektorHugo[p_max] << "\t";

    unter das if (p_max > 0 ) schreibe dann sortiert er richtig ansonsten sortiert er ja von gross nach klein.... das war mein prob und ist es immer noch

    0
  • A

    Ich glaube, Du hast da ein Problem mit dem Prinzip der Rekursion.

    1. Wenn Du die Zahl ausgibst, BEVOR der rekursive Aufruf gemacht wird, dann wird das Programm die höchste Zahl ausgeben, die es bis dahin ermittelt hat, danach die Funktion rekursiv erneut starten, und dann im wiederum die grösste bis dahin ermittelte Zahl ausgeben, etc.
    Als Beispiel folgende Funktion:

    void func1(int n)
{
   cout << n << endl;
   if (n>0) func1(n-1);
}

    Wenn Du im Programm diese Funktion mit func1(10) aufrufst, geschieht folgendes:
    Die Funktion gibt als erstes die Zahl n (im diesem Fall wäre das 10) aus, danach ruft sie sich selbst auf und zieht dabei 1 von n ab, falls n grösser als 0 ist. Nun wird wiederum n ausgegeben (jetzt 9) und wieder ruft sich die Funktion rekursiv auf, etc. Die Ausgabe wird also von 10 an rückwärts bis 0 zählen.

    2. Wenn Du die Zahl ausgibst, NACHDEM der rekursive Aufruf gemacht wurde, dann wird die Funktion solange ohne Ausgabe aufgerufen, bis die Abbruchbedingung erreicht ist. Dann gibt das Programm die ermittelte Zahl aus (das ist jetzt die kleinste Zahl...) und springt zurück zur aufrufenden Funktion, und arbeitet diese weiter ab. Dort steht jetzt wieder die Anweisung zur Ausgabe einer Zahl, usw. bis Du wieder beim ersten Funktionsaufruf gelandet bist, in dem dann die grösste Zahl ausgegeben wird.
    Analog zu oben kann man als Beispiel schreiben:

    void func2(int n)
{
   if (n>0) func2(n-1);
   cout << n << endl;
}

    Wenn man diese Funktion mit func2(10) aufruft, dann zählt die Ausgabe aufwärts von 0 bis 10. Denn zuerst wird immer func2(n-1) aufgerufen, bis n==0 ist. Und erst dann wird n ausgegeben. In diesem Fall ist natürlich die erste Ausgabe 0.

    Dein Sortieralgorithmus hat vollkommen richtig sortiert, d.h. die Elemente sind am Schluss tatsächlich von klein nach gross angeordnet. Du kannst das überprüfen, indem Du in der main-Funktion nach dem Sortieren noch alle Elemente des Arrays ausgibst:

    for(i=0; i<max; ++i)
      cout << vektorHugo[i] << endl;

    Die sind jetzt alle schön von klein nach gross sortiert.

    Gruss, Andreas

    0
Anmelden zum Antworten