Rekursives suchen in einer Liste

[Norg]

Hallo

Ich hab wieder einmal ein kleine Problem.

Angabe:
Schreiben Sie ein Programm das die Methode

public static boolean istEnthalten(int n, ListOfInt myList) //ist n in myList enthalten?

sowie eine main-Methode zum Testen anbietet. Die istEnthalten-Methode muss rekursiv definiert sein. Die main-Methode soll vom Benutzer eine int-Zahl erfragen, diese intern als Liste ihrer Dezimalziffern darstellen und dann die Benutzerfrage nach dem Vorkommen einer bestimmten Ziffer beantworten.

So, natürlich geht bei mir mal wieder nichts so wie es soll.
Beim Kompilieren bekomme ich immer die Fehlermeldungen:

Bsp24.java:30: cannot find symbol
symbol : variable head
location: class ListOfInt
if(a.head==z){

Bsp24.java:33: cannot find symbol
symbol : variable tail
location: class ListOfInt
if(a.head==z){



Bin für jede Hilfe äußerst dankbar.
Nachfolgend mein bisheriger Code:

public class Bsp24{
public static void main(String[] args) {
String s;
int z;

ListOfInt a=ListOfInt.emptyList();


System.out.println("Gib Zahl ein");
s = SavitchIn.readLine(); //Benutzereingabe einlesen 

for(int i=0; i<s.length(); i++){
a=a.add(s.charAt(i));
}
System.out.println(a); 


System.out.println("Gesuchte Zahl");
z=SavitchIn.readLineInt();

istEnthalten(z,a);
}


//---------------------------------------------------
public static boolean istEnthalten(int z, ListOfInt a){
boolean result;


if(a.head==z){
result=true;
}else {
a=a.tail;}
istEnthalten(z,a);

if (result==true)
return result;
else
return false;
}
}

Weiters die Klasse ListOfInt die ich dafür benutzen soll

public class ListOfInt{

//-----------------------------------------Instanzvariablen
private int elem;
private ListOfInt rest;
//-----------------------------------------Klassenvariablen

private static ListOfInt theEmptyList = new ListOfInt();
//-----------------------------------Konstruktoren (privat)
private ListOfInt(){}
private ListOfInt(int i, ListOfInt l){
elem = i;
rest = l;}
//----------------------------------Schnittstellenmethoden
public static ListOfInt emptyList(){
return theEmptyList;}
//liefert leere Liste

public ListOfInt add(int i){
return new ListOfInt(i,this);}
// fügt i als Element vorne hinzu

public ListOfInt tail(){
//requires notEmpty
return rest;}
//liefert Rest-Liste

public int head(){
//requires notEmpty
return elem;}
//liefert erstes Element

public boolean notEmpty(){
return (this != theEmptyList);
//true gdw. Liste nicht leer
}}

 

[Campino]

head und tail sind Funktionen und müssen als solche aufgerufen werden, also mit Klammern hinter dem Funktionsnamen.

(Es gibt übrigens keinen größeren Mist als das rekursiv zu machen, iterativ geht einfacher. Aber ich nehme mal an das das eine Hausaufage ist und wenn es dann in der Aufgabenstellung steht :roll: )

 

[Norg]

Danke für den Tipp mit den Klammern, wie konnte ich das nur übersehen.

Jetzt habe ich aber ein neues Problem, compilieren geht ohne Probleme, nur bei der Ausführung hakt es noch etwas.
Ich wollte mir meine Liste ausgeben lassen doch dabei kommt nur so etwas heraus: ListOfInt@42719c
also nicht brauchbares.
Jetzt habe ich den Verdacht dass ich meine Liste irgendwie fehlerhaft aufbaue, weiß aber nicht wirklich warum.

 

[SlaterB]

> doch dabei kommt nur so etwas heraus: ListOfInt@42719c

weil du die toString()-Operation nicht anders definiert hast,
soll Java sich selber ausdenken, was du da gerne als Ausgabe hättest?

> Jetzt habe ich den Verdacht dass ich meine Liste irgendwie fehlerhaft aufbaue, weiß aber nicht wirklich warum.

und ich habe den Verdacht, dass dein Programm nach Tomaten riecht,
aber bringt es irgendjemanden etwas, haltlose Verdachte anzubringen?

 

[Norg]

Hab das ganze jetzt nochmal ein bisschen umgebaut und komme jetzt ohne Strings aus.
Dafür bekomme ich jetzt immer einen Stack Overflow Error.
Allerdings weiß ich nicht warum, denn die Liste wird doch bei jedem Durchlauf um einen Wert kürzer.

public static boolean istEnthalten(int z, ListOfInt c){
boolean result=false;

if(c.notEmpty()==true)
if(c.head()==z){   //head gibt ersten Wert der Liste
result=true;}
else{
if(c.notEmpty()==true)
c=c.tail();}  //gibt den Rest der Liste 
istEnthalten(z,c);

if (result==true)
return true;
else
return false;
}

 

[JavaFred]

if (result==true)
return true;
else
return false;

Wenn es wahr ist, dass result den Wert true hat, dann gib den Wert true zurück, ansonsten false... 🙂

Folgender Code ist äquivalent:

return result;

 

[Leroy42]

if (result != true) 
  return false; 
else 
  return true;

ginge auch! 😎

 

[Norg]

Ich hab das jetzt mal teilweise so gelöst:

if(c.notEmpty()==true) {
 
            if (c.head() == z) {
                result = true;
                if (result == true) {
			System.out.println(result);
                    return result;
                    
               }
                else{
                    result=false;
                    System.out.println(result);
                    return result;
                } 
            }          
          
                  else {
                if (c.notEmpty() == true) {
                    c = c.tail();

                   istEnthalten(z, c);
                }
           }
        }

return result;
}
}

Er gibt mir jetzt auch schon true aus wenn die gesuchte Zahl vorkommt.
Das er false ausgibt wenn die gesuchte Zahl nicht vorhanden ist funktioniert
noch nicht so ganz und ich hab keine Ahnung warum.

 

[Leroy42]

public static boolean istEnthalten(int z, ListOfInt c) {
  return c != null &&
            (c.head() == z || (istEnthalten(z, c.tail()));
}