verificaOrdinamentoRicorsione

[carvince]

Come faccio a vedere se un array è ordinato in modo crescente???
Iterativamente lo so fare:

public static boolean verificaOrdinamento(int a[]) {
for (int i=0; i<a.length; i++)
if (a[i]<=a[i+1])
return true;
return false;
}

usando la ricorsione invece????

Ho provato così ma nn fuinziona:


public static boolean verificaOrdinamentoRicorsivo(int a[], int inizio, int fine) {
if (a.length=1)
return true;
if (a[inizio]<=a[inizio+1]
return verificaOrdinamentoRcorsivo();
return false;
}

[Alex'87]

Originariamente inviato da carvince
Ho provato così ma nn fuinziona:

Potresti anche dire gli errori che incontri...

Originariamente inviato da carvince
if (a.length=1)
return true;

Il confronto si fa con ==

Originariamente inviato da carvince
if (a[inizio]<=a[inizio+1]
return verificaOrdinamentoRcorsivo();
return false;
}

Manca la parentesi chiusa dell'if, la chiamata di funzione usa il nome sbagliato.

[andbin]

Originariamente inviato da carvince
Ho provato così ma nn fuinziona:


public static boolean verificaOrdinamentoRicorsivo(int a[], int inizio, int fine) {
if (a.length=1)
return true;
if (a[inizio]<=a[inizio+1]
return verificaOrdinamentoRcorsivo();
return false;
}

A parte gli errori già segnalati da Alex'87, il concetto comunque non è proprio quello che hai appena espresso nel codice.
Innanzitutto il 'fine' non servirebbe. Serve solo passare un 'inizio' e ogni volta che vai in ricorsione passi un inizio incrementato di 1 .... finché è possibile, ovviamente.

Non è difficile ... basta solo ragionare 1 attimo.

[carvince]

Ho provato in quest'altro modo ma mi segnale 3 errori in return VerificaOrdinamentoRicorsivo...

public static boolean verificaOrdinamentoRicorsivo(int a[], int inizio) {
if (a.length==1)
return true;
if (a[inizio]<=a[inizio+1])
return verificaOrdinamentoRicorsivo(a[inizio+1],int inizio+1);


return false;

}


Non riesco a capire come far passare un inizio incrementato di 1 ogni volta che vado in ricorsione....
Ma secondo voi if(a.length==1) return true; può essere sufficiente a fermare la ricorsione?

[andbin]

Originariamente inviato da carvince
Ho provato in quest'altro modo ma mi segnale 3 errori in return VerificaOrdinamentoRicorsivo...

A parte gli errori dovuti a cosa hai messo nella invocazione ricorsiva .... il concetto ancora non quadra.

Originariamente inviato da carvince
Non riesco a capire come far passare un inizio incrementato di 1 ogni volta che vado in ricorsione....

Passando come secondo argomento un inizio+1.

Originariamente inviato da carvince
Ma secondo voi if(a.length==1) return true; può essere sufficiente a fermare la ricorsione?

No, l'array non cambia di dimensione durante la ricorsione, l'array devi passarlo esattamente tale e quale, passi 'a' e basta. Quello che deve cambiare è il punto "logico" di inizio.
E la ricorsione si deve fermare quando inizio è l'indice dell'ultimo elemento.

Facciamo un esempio? Bene, array: 2 5 7 9

invocazione diretta con array e inizio=0: confronti 2 e 5

invocazione in ricorsione con array e inizio+1 cioè 1: confronti 5 e 7

invocazione in ricorsione con array e inizio+1 cioè 2: confronti 7 e 9

invocazione in ricorsione con array e inizio+1 cioè 3: resta 1 solo elemento, poichè 3 è l'indice dell'ultimo elemento, quindi arrivati a questo punto è di certo ordinato: true.

[carvince]

Il punto sostanzialmente ho capito qual è, il problema è tradurlo in codice...

Ho tentato in quest altro modo ma mi da errori sempre nell'invocazione ricorsiva:

public static boolean verificaOrdinamentoRicorsivo(int a[], int inizio) {
if (inizio==a.length)
return true;
if (a[inizio]<=a[inizio+1])
return verificaOrdinamentoRicorsivo(int a[], int inizio+1);


return false;

}

ho modificato la condizione inizio==a.length, l'idea sarebbe quella di verificare che se inizio è l'unico elemento dell'array allora è true ma nn so se così è giusto....


ho inoltre modificato la chiamata ricorsiva dando come parametri int a[], int inizio+1 ma in questo modo inizio si incrementerà di 1 ad ogni invocazione?

[andbin]

Originariamente inviato da carvince
if (inizio==a.length)

No, se ci sono 4 elementi l'ultimo è indice 3, non 4.

Originariamente inviato da carvince
return verificaOrdinamentoRicorsivo(int a[], int inizio+1);

Non puoi ripetere nella invocazione di un qualunque metodo i tipi, int nel caso sopra, e le [] per gli array. Qui non è una "dichiarazione" ... ma solo una espressione che denota il valore da passare, a come anche inizio+1

Originariamente inviato da carvince
ma in questo modo inizio si incrementerà di 1 ad ogni invocazione?

Sì.

[smithi]

Consiglio: leggi con attenzione gli errori che ottieni, ti aiutano a capire il problema e a risolverlo ;-)


Questo è il primo errore:

Originariamente inviato da carvince
if (inizio==a.length)

Deve essere

if(inizio == a.length - 1)

Ricorda che si inizia a contare da 0 quindi se, per esempio, il tuo array ha tre elementi, il primo elemento sarà l'elemento 0, il secondo sarà l'elemento 1 e il terzo sarà l'elemento 2. Se provi ad accedere all'elemento 3 ti dà un ArrayIndexOutOfBoundsException.



Questo è il secondo errore:

Originariamente inviato da carvince

return verificaOrdinamentoRicorsivo(int a[], int inizio+1);

Qui deve essere

return verificaOrdinamentoRicorsivo(a, inizio+1);

perché stai richiamando una funzione, non è una dichiarazione

[carvince]

Grazie 1000 ci sono riuscito!!!!
Avrei un'altra domanda:
è possibile non dichiarare la variabile inizio in verificaOrdinamentoRicorsivo
e dichiararla poi in seguito?

public static boolean verificaOrdinamentoRicorsivo(int a[]){
int inizio;
-
-
-

in questo modo ovviamente non posso fare la chiamata ricorsiva
verificaOrdinamentoRicorsivo(a, inizio+1)

come faccio allora?

[andbin]

Originariamente inviato da carvince
public static boolean verificaOrdinamentoRicorsivo(int a[]){
int inizio;

in questo modo ovviamente non posso fare la chiamata ricorsiva
verificaOrdinamentoRicorsivo(a, inizio+1)

Chiaramente no.

Originariamente inviato da carvince
come faccio allora?

Un metodo "pubblico" che riceve solo int[] e un metodo "privato" a cui deleghi la prima invocazione e la invocazione ricorsiva, che riceve int[] e anche int inizio