[JAVA] rekurzivni izpis seznama z kazalci

V javi mam en program, ki mi zgradi enosmerno povezan seznam z kazalci in ga napolni z objekti nekega mojga razreda.
Sedaj pa bi ga rad izpisal in sicer rekurzivno in po desetinah. Rekurzivni izpis sam mi ne dela težav, nikakor pa mi ne rata da bi mi ta seznam izpisal po desetinah.
Recmo d mamo v seznamu 100 elemntov bi izpisal 10,20,..., 100

Tukaj je še koda za samo rekurzivni izpis

//rekurzivni izpis celega seznama
private static void izpis_seznamaL( Object iter )
	{
		if( ! slovar_L.overEnd(iter) )
		{	
			System.out.println( slovar_L.retrieve( iter ) );
			izpis_seznamaL( iter = slovar_L.next(iter) );	
		}
	}


//klic zgornje metode; .first() vrne kazalec na prvi element seznama tega potem kot parameter podamo metodi
//.izpis_seznamaL()
Object iter = slovar_L.first();
izpis_seznamaL( iter);

Ni tko, mogoč sm mal slab napisu bom poskusu še 1x

tvoja koda dela tko da izpiše vsak deseti vnos, recmo mam v seznamu 300 elemetov bo izpisal elemente na 10,20,30,.. 300 poziciji pač vsakega desetega skupaj 30 izpisov.

Jest pa rabm d je točn 10 izpisov. Izpiše vsako desetino seznama. V zgornjem primeru bo izpisal elemente na poziciji 30,60,...,300

Mnja proh hitr mi vrže zdej stackOverFlow exception
Sicer dela že sam to me še muči
Pa ni mi jasn zakaj pride do te napake, sej če izpisuješ vse dela tu pa sam en dodatn parameter še šibaš naprej se pa krešira :s

Če je preveč za rekurzijo pa uporabi normalno while iteracijo, ki je tak ali tak hitrejša in manj omejena.

private static void izpis_seznamaL( )
	{
		int counter = 0;
		Object iter;

		while( ! slovar_L.overEnd(iter) )
		{	
			if (counter % (slovar_L.size() / 10))
				System.out.println( slovar_L.retrieve( iter ) );
			iter = slovar_L.next(iter);
			counter+=1;
			
		}
	}

stack imaš omejen , jvm ne poznam v podrobnosti ampk ne gre rekurziven sklic v neskončnost pa da ga jebeš. je pa možno da zna jvm(ampak to ne vem zares) tail rekurzijski sklic pretvorit v iteracijo. potem se lahko graš na ta nalin. ampak v splošnem to rekurzijo ne boš na dandanašnjih arhitekturah učinkovito urotil kar tako.

nima veze smetar tu , stack ni neomejen. če bi bil zlahkoto povoziš najprej aplikacijo nato pa tudi os. pomnilik pravzaprav zasega os in zgodovina kot s evleče je ugotovila , da je to vrstno programiranje nevarno, se zna spremenit. ampak ne in general , stvari se pribajo reševar na ravni semantike jezika ugotovit kje je rekurzija in spremenit v itaracijo. za repno se to da avtomatizirat. za druge je pa težje. se dela na tem sam prekmau smo rojen , ...

no nasplošno pa prav zavese se ne da povedat da se da, oz tudi če se da mogoče ugotavljanje zahteva nedoločen čas če se še kej spomnem postulatov.

pa ne mečte kamna po men!

Mogoce pa kaj takega:

private static void izpis_seznamaL( Object iter, int st_izpisov )
	{
                if (st_izpisov == 0) return;  // izhod iz rekurzije
                int i = slovar_L.size(iter) / st_izpisov; //size(iter) vrne velikost podseznama od iter do end
                while (!slovar_L.overEnd(iter) && (--i > 0)) iter = slovar_L.next(iter) ;
		if( ! slovar_L.overEnd(iter) )
		{	
			System.out.println( slovar_L.retrieve( iter ) );
			izpis_seznamaL( iter = slovar_L.next(iter), st_izpisov -1 );	
		}
	}

Torej, na zacetku imas cel seznam, za eno desetino se postavis na desno (z while zanko), izpises element, na katerega kaze iter, ter rekurzivno na ostanku seznama sedaj gres izpisovat devetino preostalega seznama ...

Probaj povečat velikost stacka v javi. Mislim da to nardis z -Xmx512M (nisem ziher preveri z java -X).
Še enkrat - to ni rešitvev problema. Če bo delal zdaj algoritem za 10000 elementov, mogoče pa ne bo za 1000000 ali 10000000 elementov.

Prava dobra rešitev je Geneticova, saj je rekurzivna in hkrati do stack overflowa ne more prit kar tako hitro. Tudi sam sem imel idejo, za kaj takšnega ampak ko sem o njej razmišljal se mi ni zdela prava.