rekursiv-funktion zur bestimmung max von einem array

hallo,
ich möchte den max von einem array finden. die funktion dazu muss rekursiv sein
ich brauche einen algorithmen oder einen denkanstoss
mein versuch bis jetzt scheitert:

#include<stdio.h>

int eingabe(int* feld);
void ausgabe(int* feld, int gr);
int max_rek(int* feld, int gr);
int main()
{
  int gr;
  int feld[100];
  int max;
  gr = eingabe(feld);
  ausgabe(feld,gr);
  max = max_rek(feld,gr);
  printf("max = %d",max);

  return 0;
}

int eingabe(int* feld)
{
  int gr;
  int i;
  printf("Geben sie eine Feldgroesse zwischen 1 und 100:\n");
  scanf("%d",&gr);
  for(i=0;i<gr;i++)
  {
    printf("%d-ste element: \t", i+1);
    scanf("%d",&feld[i]);
  }
  return gr;
}

void ausgabe(int* feld, int gr)
{
  int i;
  printf("\n");
  printf("ausgabe:\n");
  for(i=0;i<gr;i++)
  {
    printf("%d-ste element: %d\n", i+1,feld[i]);

  }
}

int max_rek(int* feld, int gr)
{
  int i,j;
  for(i=0;i<gr;i++)
  {
     for(j=i+1;j<gr+2;j++)
     {
       gr--;
       if(feld[i]<feld[j])
       {
          max_rek(feld+j,gr);
       }
     }
  }
  if(j>1)
     return feld[i-1];//hier greift er auf den falschen element
  else
     return feld[j-1];//hier greift er auf den falschen element

}

danke im voraus
youssef

junix

Sehe zwar nicht ein wozu das Ganze rekursiv sein muss (eine Schleife täte das ihre...) aber was ich sehe lässt vermuten, das dir Rekursion nicht wirklich viel sagt oder?

Ausserdem reschliesst sich mir nicht was du genau realisiern wolltest. Kommentare wären hier angebracht.

das ganze muss rekursiv sein weil die Aufgabenstellung so ist.
eine rekursive funktion ist eine funktion die sich selbst aufruft.
Einen solchen Selbstaufruf nennt man Rekursion oder ?
was ich realisieren möchte ist eine rekursive funktion die den maximum eines int-array bestimmt.
ich vergleiche jede 2 feldelementen

int max_rek(int* feld, int gr)
{
  int i,j;
  for(i=0;i<gr;i++)// schleife fuer den ersten operand
  {
     for(j=i+1;j<gr+2;j++)// schleife fuer den zweiten operand
     {
       gr--;// groesse dekrementieren
       if(feld[i]<feld[j])
       {
          //feld[i] ist nicht mehr interessant 
          max_rek(feld+j,gr);// -> feld zeigt auf feld[j]
       }
      else
      {
        // vergleiche feld[i] mit dem nächsten element
      }
     }
  }
      return feld[i];// welches index i ?

}

irgendwelche idee ?
vielen dank für eure bemühungen

pli

int findMax( int *array, int length, int oldMax)
{
  if( length == 1 )
  {
    return oldMax>array[0]?oldMax:array[0];
  }
  else
  {
    oldMax = oldMax>array[0]?oldMax:array[0];
    return findMax( array++, length-1, oldMax );
  }
}

Edit: zum starten

int max = findMax( myArray, myArrayLength, INT_MIN );

in der main() oder so eingeben und limits.h includen (fuer INT_MIN, kleinster Wert den int annehmen kann)

Alex_H

Hallo,
Vorschlag statt IntMin könnte man auch das erste FeldElement übergeben.

Gruß Alex

pli

Alex_H schrieb:

Hallo,
Vorschlag statt IntMin könnte man auch das erste FeldElement übergeben.

Gruß Alex

dann aber bitte auch mit "array+1" und "length-1" starten, so kann man sich den ersten Rekursionsschritt sparen

Alex_H

ok mach auf jedenfall Sinn aber irgendwann sollte man dann überlegen, ob es sinnvoll ist die Länge 0 abzufangen, bzw. ob man das von vornherein hätte machen sollen. Aber man will youssef ja nicht den ganzen Spaß abnehmen.

Gruß Alex

pli

Alex_H schrieb:

ok mach auf jedenfall Sinn aber irgendwann sollte man dann überlegen, ob es sinnvoll ist die Länge 0 abzufangen, bzw. ob man das von vornherein hätte machen sollen. Aber man will youssef ja nicht den ganzen Spaß abnehmen.

Gruß Alex

Waere ja kein Problem, statt bei lenght == 1 brichst bei 0 ab und gibst oldMax zurueck. Aber dann muesste man auch pruefen ob das array != NULL ist und das nimmt ja die ganze Spannung aus dem Programmieren. Wenns keine Fehler gaebe waer das ja langweilig....

Konfusius

wenns richtig rekusiv werden soll, dann schlage ich vor, daß du das array in zwei arrays aufteilst und dann das maximum der beiden array-hälften vergleichst:

int
max_rek (int *feld, int gr)
{
  int a,b;

  if(gr==1) return *feld;

  a=max_rek(feld,gr/2);
  b=max_rek(feld+gr/2,gr-gr/2); 

  return (a>b ? a : b);
}

gr-gr/2 ist nicht gleich gr/2! da gr/2 eine ganzzahlige division ist träte bei ungeradem gr ein rundungsfehler auf und das letzte element des arrays würde nicht in die maximumsprüfung mit einbezogen werden!