Citat:
Ursprungligen postat av
dagsvag
Tack! mycket bra information.
Lite sen på bollen (igen), men ville bara påtala att du har fått svar av lite blandad kvalitet.
Precis som poolo skriver tycker jag att du bör använda dig av indexOf för att lösa detta. Använd inte instansvariabler av något slag utanför metoden för att lösa detta. Inte som i föreslaget med att göra metoden generell (utan lägg i så fall till en parameter till metoden) och absolut inte en för att räkna antal med. Det sistnämnda bryter mot hela den rekursiva tanken. Det vore lika illa som att lägga en intern loop-variabel i någon metod som en instansvariabel istället. Precis som du i en loop eller annat slutet scope använder lokala variabler, som enbart existerar medans du utför beräkningen, så skall du under rekursion använda anropsstacken och returvärden för samma syfte. Alla variabler som är synliga utanför sitt tänkta syfte riskerar att bli nyttjade felaktigt och dessutom blir inte din metod trådsäker.
Nu kanske du har lämnat detta bakom dig, men ifall andra läser detta framöver, så är här lite kompletterande tankar runt rekursion som kanske är av intresse.
En gammal bra beskrivning för att lära sig förstå den rekursiva grundtanken tycker jag denna är (minns inte källan längre):
Att utföra en rekursiv operation på en samling element innebär att först utföra operationen på det första elementet och sen samma sak på resten, dvs alla element utom det första.
Komplettera detta med ett avbrottsvillkor, dvs hantera fallet när samlingen består av noll element, så är lösningen komplett.
Applicera nu denna tanke på ett minimalt konkret exempel, som att summera en samling heltal rekursivt. Ovanstående säger ju då att summan av alla element är första värdet i samlingen plus summan av alla återstående element. Avbrottsvillkoret blir att returnera 0 för en tom samling. Kodexempel (där ix är startposition för summering och som borde kompletteras med en överlagrad sum(int[]) som anropar denna med 0 som arg för ix, men skippat för att hålla exemplet litet):
Kod:
public static int sum(int[] array, int ix) {
return ix >= array.length ? 0 : array[ix] + sum(array, ix + 1);
}
Denna följer den rekursiva tanken ovan: Om samlingen är tom (ix >= array.length) returnera 0 annars returnera första elemetet (array[ix]) + summan av resten (sum(array, ix + 1)).
Om man nu använder sig av indexOf för problemet i denna tråd så blir motsvarande rekursiva tanke denna: Hitta första förekomst av strängen "hi" och summera denna träff med antalet övriga träffar i återstående sträng (dvs resterande sträng efter första träff). Avbrottsvillkor blir att returnera 0 om vi inte hittar någon träff alls. Med mallen ovan för lösningen av sum() så kan man konstruera en rätt likt exempel (samt generalisera den, anropa med "hi" som andra argument för övningen i denna tråd):
Kod:
public static int count(String s, String match) {
int ix = s.indexOf(match);
return ix == -1 ? 0 : 1 + count(s.substring(ix + match.length()), match);
}
Eller som någon föreslog att det borde formuleras i ordböckerna:
Kod:
rekursion:
se rekursion
Det dolda avbrottsvillkoret här är helt enkelt att läsaren till sist fattar.
