Probleme bei Ausgabe von rekursiver Methode (List)

[Siebenkern]

Moin!

Ich habe ein kleines Problem mit einem Programm.
Ein Fehler, der meiner Meinung nach nicht auftreten sollte.
und zwar wird mir folgendes angezeigt:

"Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The operator + is undefined for the argument type(s) List<Integer>, List"

Und zwar hier:

static List zip(List<Integer> vs, List<Integer> ws){
		
		List<Integer> intern = new LinkedList<Integer>();
		if(vs.isEmpty() && ws.isEmpty()) return null;
		if(ws.isEmpty()){ intern.add(vs.remove(0)); return zip(vs, ws);}
		if(vs.isEmpty()){ intern.add(ws.remove(0)); return zip(vs, ws);}
		intern.add(vs.remove(0));
		intern.add(ws.remove(0));
		return intern + zip(vs, ws);  //hier wird der Fehler angezeigt.

Muss ich das "+"-Zeichen irgendwie noch einmal genau definieren?

 

[Tiding]

Naja,
intern gibt dir List<Integer> zurück und
zip(vs, ws) gibt dir List zurück.

Die Exception sagt dir, dass du List + List<Integer> nicht machen darfst.

Wo liegt jetzt genau das Problem? ???:L

Könnte ja passieren, dass du dann String[] + int rechnest...

 

[Siebenkern]

Das "+" war gedacht, damit die Methode sich selbst wieder aufruft, also rekursiv ist.
Auf diese Weise sollen die Listen vs und ws zu der Liste intern verschmelzen.
Was müsste ich da am besten ändern, damit dies geschieht?

 

[njans]

return intern .addAll(zip(vs, ws));

Das müsstest du ändern. Der + Operator hat keine Funktion auf Listen in Java.

 

[Siebenkern]

Das erzeugt bei mir nur einen anderen Fehlercode, weil die Ausgabe der Liste plötzlich zu Boolean wird.
("Type mismatch: cannot convert from boolean to List")

Aber vielleicht habe ich es auch einfach nur dumm erklärt:

Ich wollte, dass die Listen vs (z.B.: 1, 3, 5, 7) und ws(z.B.: 2, 4, 6, 8) zu der Liste intern(1, 2, 3, 4, 5, 6, 7, 8) verschmelzen.

Deshalb wollte ich eine Möglichkeit finden, dass zwar schon einmal die ersten zwei Objekte der Liste intern ausgegeben werden, aber die Methode sich danach noch einmal selbst wieder aufruft, um auch die restlichen Objekte in die Liste zu übernehmen und auszugeben.

 

[Tiding]

Ahhhh, jetzt verstehe ich was das da oben machen soll! :bloed: 😀

Da ich nix besseres zu tun hab, schau ich mal was meinem Köpfchen so alles dazu einfällt ^^

 

[Tiding]

    static List verschmelzen(List<Integer> List1, List<Integer> List2){
    	if(List1 != null) List1.addAll(List2);
    	else return List2;
    	return List1;
    }

Das ganze noch ordnen lassen und fertig.

ich weiß jetzt nicht; musst du das ganze rekursiv lösen? Weil die Methode addAll macht ja genau das was du willst 😱!

 

[rme]

Durch [c]addAll[/c] wird [c]intern[/c] modifiziert - du kannst doch einfach danach [c]return intern;[/c] machen, oder nicht?

Darf ich fragen, an welcher Uni man gezwungen wird, die Wunder der funktionalen Programmierung ausgerechnet in Java zu lernen? Die Sprache ist dafür doch denkbar ungeeignet und man wird eher demotiviert, jemals wieder an Rekursion zu denken, sobald man damit durch ist..

 

[Tiding]

Was im üprigen dein Problem angeht:

ja der Rückgabetype von add ist boolean, aber das Element wird der Liste mit Aufruf dieser Methode zugefügt, also erst die Methode aufrufen und dann die neue Liste, die nun ein Objekt mehr hat zurückgeben.

 

[Siebenkern]

Also erst mal vielen Dank, dass ihr euch alle die Mühe macht 🙂

Ich muss diese Aufgabe unbedingt rekursiv lösen. Wichtig wäre auch, dass ich dabei nicht im nachhinein ordne, sondern das von alleine in diese Reihenfolge gebracht wird.

Liste a (a, a, a, a, a, a)
Liste b (b, b, b, b, b, b)
--> (a, b ,a ,b ,a ,b,...)

Deswegen suche ich nach einem Weg, dass nicht nur die ersten beiden Elemente eingefügt werden, sondern beide Listen so abgearbeitet werden.

Achja, ich studiere an einer Fachochschule. Vielleicht liegt es ja daran 😀

 

[Siebenkern]

Weiß da keiner weiter?
Die bisherigen Antworten helfen mir leider nicht weiter 🙁

 

[Tiding]

Hilft dir das evtl. weiter?

    static List<Integer> zip(List<Integer> intern, List<Integer> list1, List<Integer> list2){
    	if(list1.isEmpty() && list2.isEmpty()) return intern;
        if(list2.isEmpty()){
        	intern.addAll(list1);
        	return intern;
        }
        if(list1.isEmpty()){
        	intern.addAll(list2);
        	return intern;
        }
        intern.add(list1.get(0));
        intern.add(list2.get(0));
        list1.remove(0);
        list2.remove(0);
        return intern = zip(intern, list1, list2);  
    }

 

[Tiding]

anders, sprich ohne eine äußere Liste, in die du die jeweiligen Elemente einfügen kannst, fällt mir nichts ein, wobei es noch fraglich ist, ob das überhaupt möglich ist. ???:L :bahnhof:

 

[Siebenkern]

Also erst mal ein dickes Danke, weil du mir heute ganz gut geholfen hast.
Aber in der Aufgabenstellung ist leider explizit gefordert, dass dort die Ausgabe so ist, wie ich sie in dem vorletzten Post beschrieben hatte. Daher bringt mich das auch nicht weiter.
Aber ich kann ja morgen, wenn wir die Lösungen bekommen haben, zeigen, was gefordert war.
Ich häng da schon seit stunden dran und weiß einfach nicht weiter, aber scheinbar bin ich nicht der Einzige.

Also gut, dann schon mal eine gute Nacht und bis morgen! 🙂

 

[Tiding]

Gute Nacht!
Ja, sobald man dann die Lösung sieht, denkt man sich nur: Warum bin ich denn darauf nur nicht gekommen 😀! :bloed:

 

[Tiding]

Obwohl ich gerade die Lösung des Problems gefunden habe 😱

 

[Tiding]

    static List<Integer> zip(List<Integer> list1, List<Integer> list2){
    	List<Integer> intern = new LinkedList<Integer>();
    	if(list1.isEmpty() && list2.isEmpty()) return intern;
        if(list2.isEmpty()){
        	intern.addAll(list1);
        	return intern;
        }
        if(list1.isEmpty()){
        	intern.addAll(list2);
        	return intern;
        }
        intern.add(list1.get(0));
        intern.add(list2.get(0));
        list1.remove(0);
        list2.remove(0);
        intern.addAll(zip(list1, list2));
        return intern;  
    }

Garnichtmal so anders! :bloed: 😛opcorn: 😀