Frage zur Rekursion

Hallo,
ich bin noch Änfänger, was das Programmieren mit c++ betrifft.
Ich soll ein Programm schreiben, dass Zahlen nach der Größe sortiert. Das Programm hab ich geschrieben und es funktioniert auch. Nur soll ich das Programm mit Rekursion lösen und weiss nicht wie ich das machen kann.
Hoffe ihr könnt mir helfen.

Gruß andi

int main()
{
const int max=50;
int daten[max]={0};
int zaehler=0,zahl,Lauf,Schritt,temp,i;
do{
cout<<"Zahl eingeben/0=Abbruch"<<endl;
cin>>zahl;
daten[zaehler]=zahl;
zaehler++;
}
while(zahl!=0&&zaehler<=max);

for(Lauf=1; Lauf<zaehler; Lauf++)
{
for(Schritt=zaehler-1;Schritt>=Lauf;Schritt--)
{
if(daten[Schritt-1]> daten[Schritt])
{
temp=daten[Schritt-1];
daten[Schritt-1]=daten[Schritt];
daten[Schritt]=temp;
}
}
}
for(i=0;i<zaehler;i++)
cout<<daten[i]<<" ";

return 0;
}

C++ Forumbot

Dieser Thread wurde von Moderator/in Jochen Kalmbach aus dem Forum C++/CLI mit .NET in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Verwende doch einfach einen Sortieralgorithmus der eine rekursive Natur hat, dann fällt es dir auch ganz leicht den rekursiv zu impelementieren.

www.sortieralgorithmen.de sollte dir dabei sicher behilflich sein

Konrad Rudolph

lolz_offline schrieb:

Verwende doch einfach einen Sortieralgorithmus der eine rekursive Natur hat

Welcher hat das nicht?

Folgender Code ist recht kurz (und damit relativ einfach) und rekursiv:

template <typename RanIter>
void bubblesort(RanIter begin, RanIter end)
{
    if (begin + 1 == end) return;
    bubblesort(begin + 1, end);
    if (*(begin + 1) < *begin) std::swap(*begin, *(begin + 1));
    bubblesort(begin + 1, end);
}

Andi, falls Dir das mit den Templates zu kompliziert ist, kannst Du es auch folgendermaßen vereinfachen:

void bubblesort(int* begin, int* end)
{
    if (begin + 1 == end) return;
    bubblesort(begin + 1, end);
    if (*(begin + 1) < *begin) std::swap(*begin, *(begin + 1));
    bubblesort(begin + 1, end);
}

Aufgerufen wird der Code in beiden Fällen gleich, z.B. so:

int a[] = { 5, 3, 3, 5, 2, 7, 8, 4, 9, 6, 4, 5, 2, 1, 3 };
bubblesort(a, a + 15);

Konrad Rudolph schrieb:

lolz_offline schrieb:

Verwende doch einfach einen Sortieralgorithmus der eine rekursive Natur hat

Welcher hat das nicht?

Folgender Code ist recht kurz (und damit relativ einfach) und rekursiv:
template <typename RanIter>
void bubblesort(RanIter begin, RanIter end)
{
    if (begin + 1 == end) return;
    bubblesort(begin + 1, end);
    if (*(begin + 1) < *begin) std::swap(*begin, *(begin + 1));
    bubblesort(begin + 1, end);
}
Andi, falls Dir das mit den Templates zu kompliziert ist, kannst Du es auch folgendermaßen vereinfachen:
void bubblesort(int* begin, int* end)
{
    if (begin + 1 == end) return;
    bubblesort(begin + 1, end);
    if (*(begin + 1) < *begin) std::swap(*begin, *(begin + 1));
    bubblesort(begin + 1, end);
}
Aufgerufen wird der Code in beiden Fällen gleich, z.B. so:
int a[] = { 5, 3, 3, 5, 2, 7, 8, 4, 9, 6, 4, 5, 2, 1, 3 };
bubblesort(a, a + 15);

Jetzt hat er sicher gelernt wie man rekursiv programmiert

Konrad Rudolph

ZiggySdardusd schrieb:

Jetzt hat er sicher gelernt wie man rekursiv programmiert

Hat er sicher nicht. Aber wenn er sich meinen Code mal anschaut, dann in der Wikipedia den Artikel über Rekursion liest und sich dann noch einmal mit dem Code auseinandersetzt, dann hat er eine gute Chance, sowohl Rekursion als auch meinen Code zu verstehen. Und einen funktionierenden Code hat er auch.

Danke für die Antworten, aber die Rekursion habe ich leider noch nicht verstanden. Der Aufgabensteller hat gemeint ich soll einfach die innere for-Schleife in eine rekursive Funktion auslagern. Könnt ihr mir da helfen?

Danke schon mal
Andi

# include <iostream>
using namespace std;

int main()
{

int anzahl,zaehler=0,zahl,Lauf,Schritt,temp,i;
cout<<"Anzahl"<<endl;
cin>>anzahl;
const int max=100;
int daten[max]={0};
do{
cout<<"Zahl eingeben"<<endl;
cin>>zahl;
daten[zaehler]=zahl;
zaehler++;
}
while(zaehler<anzahl);

for(Lauf=1; Lauf<zaehler; Lauf++)
{
for(Schritt=zaehler-1;Schritt>=Lauf;Schritt--) = rekursiv
{
if(daten[Schritt-1]> daten[Schritt])
{
temp=daten[Schritt-1];
daten[Schritt-1]=daten[Schritt];
daten[Schritt]=temp;
}
}
}
for(i=0;i<zaehler;i++)
cout<<daten[i]<<" ";

return 0;
}

Konrad Rudolph schrieb:

lolz_offline schrieb:

Verwende doch einfach einen Sortieralgorithmus der eine rekursive Natur hat

Welcher hat das nicht?

Bogosort?

TactX schrieb:

Konrad Rudolph schrieb:

lolz_offline schrieb:

Verwende doch einfach einen Sortieralgorithmus der eine rekursive Natur hat

Welcher hat das nicht?

Bogosort?

template<typename IteratorType>
void bogosort(IteratorType begin, IteratorType end) {
    radomshuffle(begin, end);
    if(!issorted(begin, end)) {
        bogosort(begin, end);
    }
}

hi,
kann mir da keiner helfen? :xmas1:

gruß andi

Du musst das was in der Schleife ist in die Funktion packen und diese ruft sich immer wieder selbst auf. Damit sie sich nicht unendlich oft aufruft, musst du noch ein abbruchkriterium bestimmen (wie bei der Schleife), wenn dieses erreicht ist, ruft sie sich nicht mehr auf, sondern springt zurück (nicht ganz, sondern nur einen Aufruf).