[C++] Problemi con ricorsione

[Marco1995]

Salve ragazzi!Vi scrivo perchè non riesco proprio a capire il funzionaento del metodo ricorsivo..ad esempio dato questo programma:

Assegnato un vettore di elementi,scrivere una funzione ricorsiva che calcoli il minimo valore tra la differenza di ogi elemento con il precedente

Io ho provato a buttare giù qualcosa del tipo:

#include<iostream>
using namespace std;
int Differenza(double *n,int indice,int risultato);
int main()
{
    double n[3]={8,4,5};
    cout << Differenza(n,2,0);
    return 0;
}
int Differenza(double *n,int indice,int risultato)
{

    if (indice == 0)
        return risultato;

    risultato = n[indice]-n[indice-1];
        if (risultato>Differenza(n,--indice,risultato))  //Quando qua decremento l'indice,...
           risultato = Differenza(n,--indice,risultato) ;//Quava decrementato ulteriormente?
}

Solo che:1)Non viene;2)Non sono molto convinto del metodo da me utilizzato.

Premetto che il calcolare le somme,i prodotti e altri calcoli iterativamente (ad es.il fattoriale) sono capace,ma quando si tratta di fare dei confronti all'interno della funzione vado in palla
Suggerimenti?

[Scara95]

#include<iostream>
using namespace std;
double Differenza(double *n,int indice);
int main()
{
    double n[3]={8,4,5};
    cout << Differenza(n,2);
    return 0;
}
double Differenza(double *n,int indice)
{

    if (indice == 1)
        return n[indice]-n[indice-1];
    
    double this = (n[indice]-n[indice-1]), rec = Differenza(n, indice-1);
    
    return (rec < this) ? rec : this;      
}

o meglio

#include<iostream>
#include <limits>
using namespace std;
double Differenza(double *n,int indice,double min);
int main()
{
    double n[3]={8,4,5};
    cout << Differenza(n,2,numeric_limits<double>::max());
    return 0;
}
double Differenza(double *n, int indice, double min)
{

    if (indice == 0)
        return min;
    
    return Differenza(n, indice - 1, ((n[indice]-n[indice-1]) < min) ? (n[indice]-n[indice-1]) : min);
}

Comunque si tratta di C++ e non di C...

[Marco1995]

Innanzitutto grazie della risposta...ma mi piacerebbe avere anche dei commenti del codice da te utilizzato e dei commenti ai miei errori...grazie ancora.

Comunque si tratta di C++ e non di C...

E' vero hai ragione

[Scara95]

#include<iostream>
using namespace std;
double Differenza(double *n,int indice);
int main()
{
    double n[3]={8,4,5};
    cout << Differenza(n,2);
    return 0;
}
double Differenza(double *n,int indice)
{
    //Se ci sono solo due valori la differenza minima è la differenza fra questi due
    if (indice == 1)
        return n[indice]-n[indice-1];
    //-
    
    //Trovo la differenza fra gli ultimi 2 elementi
    double this = (n[indice]-n[indice-1]);
    //-

    //Trovo la differenza minimima degli elementi precedenti
    double rec = Differenza(n, indice-1);
    //-
    
    //Ritorno il valore minore
    return (rec < this) ? rec : this;
    //- 
}

#include<iostream>
#include <limits>
using namespace std;
double Differenza(double *n,int indice,double min);
int main()
{
    double n[3]={8,4,5};
    //Args: l'array, l'indice >, il > valore possibile (Gli altri saranno neccessariamente <)
    cout << Differenza(n,2,numeric_limits<double>::max());
    //-
    return 0;
}
double Differenza(double *n, int indice, double min)
{
    //Se l'indice è 0 non esiste un valore precedente: ritorno l'argomento min (differenza minima)
    if (indice == 0)
        return min;
    //-
    
    //Args: array, indice-1 (calcolo differenza < sui valori precedenti), differenza ultimi due elemnti se questa è < di min, altrimenti min
    return Differenza(n, indice - 1, ((n[indice]-n[indice-1]) < min) ? (n[indice]-n[indice-1]) : min);
}

[Marco1995]

Ok..ma potresti dirmi cos'è quel numeric_limit?E' una sorta di costante che indica il massimo valore assumibile dal tipo specifico?E' una costante all'interno di <limits> ?
Comunque devo assimilarmi un pò il codice e rassegnarni all'idea che funzioni...magari mi aiuterò con il debugger . .
Un'ultima cosa ...a cosa serve la ricorsione che se gestita male può portare un overflow (credo si dica così) della memoria?

[Scara95]

È un template della libreria standard, sì, in questo caso serve per il valore massimo assumibile da double...

La ricorsione serve a semplificare le definizioni, utilizzi per definire la funzione la funzione stessa, quindi ti basta definire il caso base e quello normale...
Una volta capito il meccanismo sono assai di più facile comprensione...

[Marco1995]

Una volta capito il meccanismo sono assai di più facile comprensione...

Il problema sta proprio nel capire il concetto D:
Non è per niente facile..ad ogni modo grazie delle spiegazioni
Ciao, alla prossima

[Scara95]

Originariamente inviato da Marco1995

Una volta capito il meccanismo sono assai di più facile comprensione...

Il problema sta proprio nel capire il concetto D:

Ti consiglio di leggere The Little Schemer...

Non è per niente facile..ad ogni modo grazie delle spiegazioni
Ciao, alla prossima

Non c'è di che

[Marco1995]

The little schemer?Di cosa si tratta?Esiste anche una versione in italiano? :P

[Scara95]

Originariamente inviato da Marco1995
The little schemer?

Già...

Di cosa si tratta?

Dovrebbe essere un'introduzione al linguaggio Scheme, è più che altro un'introduzione alla ricorsione e alle Higher-order function che usa Scheme come veicolo.
E' ricco di esempi ed esercizi e ti permette di capire concretamente la ricorsione e di capirne l'utilità...

Esiste anche una versione in italiano? :P

Non ne ho idea