Rekursja początki.

0

Hej!
Chce się nauczyć rekursji w javie ale jakoś nie mogę tego zrozumieć.
Moim zadaniem jest odwrócenie tablicy char'ów.
Oto mój kod:

static char reverse(char[] tab) {
		int q = tab.length;
		int p = 0;
			char temp = tab[p];
			tab[p] = tab[q - 1];
			tab[q - 1] = temp;
			
			if (tab.length % 2 != p) {
				return tab[tab.length/2];
						}
			p++;
			q--;
		return reverse(tab);
	}

Mógłby ktoś dobry posłużyć pomocą, albo dać jakieś wskazówki? Chciałbym zrozumieć tą rekursje :)
poprawiłem literówkę w tytule - bogdans

0

Jeżeli chodzi co o odwrócenie kolejności to tot jest twój kod w którym nie potrzebna jest rekursja:

package main;

public class Main {
	public static void main(String[] args) {
		char[] array = "Siemanko!".toCharArray(); //Nasza tablica
		char[] newArray = new char[array.length]; //Nowa tablica o długiści starej
		int i2 = 0; //licznik 2
		for(int i = array.length - 1 /*Licznik 1*/; i >= 0 ; i-- /*Dekrementacja i*/) {
			newArray[i2] = array[i]; //Ustawienie wartości
			i2++; //inkrementacja i2
		}
		for(char c : newArray) { //Wyświetlenie tablicy
			System.out.print(c);
		}
	}
}

A jeśli chcesz nauczyć się rekursji to dam ci przykłąd funkcji mnożocej liczbę przez 2 kilka razy:

package main;

public class Main {
	public static void main(String[] args) {
		System.out.println(mnóżPrzezDwa(5 , 2));
	}
	static int mnóżPrzezDwa(int ile, int ileRazy) {
		if(ileRazy >= 1) {
			ileRazy--;
			return mnóżPrzezDwa(ile * 2, ileRazy);
		} else {
			return ile;
		}
	}
}
0

Funkcję opartą na pętli typu (kod pseudo-java z rozpakowywaniem krotek):

Typ1 funkcja(TypP1 p1, TypP2 p2, ...., TypPN pN) {
  TypL1 l1 = w1;
  TypL2 l2 = w2;
  ...
  TypLN lN = wN;
  while (warunek) {
    (l1, l2, ..., lN) = funkcja1(p1, p2, ..., pN, l1, l2, ..., lN);
  }
  return funkcja2(p1, p2, ..., pN, l1, l2, ..., lN);
}

Możesz trywialnie zamienić na rekurencję w taki sposób:

Typ1 funkcjaWstępna(TypP1 p1, TypP2 p2, ..., TypPN pN) {
  TypL1 l1 = w1;
  TypL2 l2 = w2;
  ...
  TypLN lN = wN;
  return funkcjaRekursywna(p1, p2, ..., pN, l1, l2, ..., lN);
}

Typ1 funkcjaRekursywna(TypP1 p1, TypP2 p2, ..., TypPN pN, TypL1 l1, TypL2, ..., TypLN lN) {
  if (warunek) {
    return funkcjaRekursywna(p1, p2, ..., pN, rozpakujKrotkę(funkcja1(p1, p2, ..., pN, l1, l2, ..., lN));
  } else {
    return funkcja2(p1, p2, ..., pN, l1, l2, ..., lN);
  }
}

p1, p2, etc to parametry (tutaj stałe, bo nie lubię podmieniać parametrów w środku funkcji)
l1, l2 etc to zmienne (w wersji pierwszej)/ stałe (w wersji drugiej) lokalne (po konwersji stają się parametrami)

Powstała rekurencja to rekurencja ogonowa, więc kompilator z TCO (tail call optimization) jest w stanie zamienić drugą postać z powrotem na pętlę.

pozdro :]

1 użytkowników online, w tym zalogowanych: 0, gości: 1