Problem mit abstraktem Datentyp Liste

lima-city → Forum → Programmiersprachen → Java

Autor dieses Themas
garlian

garlian hat kostenlosen Webspace.
15:10, 1.3.2010
Hallo liebe Leute,
wir nehmen zurzeit in unserem Info LK abstrakte Datentypen in Java durch und ich tue mich damit irgendwie ziemlich schwer, habe ich das Gefühl. Wir sollen ein Programm in Java erstellen, was uns den abstrakten Datentyp Liste zur Verfügung stellen soll, aber irgendwie will mein Proggi nicht so wie ich will :(

Hier einmal der Code:
Main.java
```
public class Main {

	public static void main (String args[]) {		
		Liste a1 = new Liste();
		a1.insert(15);
		a1.insert(27);
		a1.insert(60);
		a1.insert(16);
		a1.insert(28);
		a1.insert(61);
	}
}
```
Liste.java
```
public class Liste {
	Element anfang, aktuell;
	
	public void insert(int wert) {
		if(isEmpty()) {
			Element x = new Element(wert);
			anfang = x;
			aktuell = x;
			System.out.println("Start new List:"+anfang.getWert());
		} else {
			if(wert < aktuell.getWert()) {
				Element x = new Element(wert);
				x.setZeiger(aktuell);
				System.out.println("Show new order "+x.getWert()+" show pointer "+x.getZeiger().getWert());
			} else {
				Element x = new Element(wert);
				aktuell.setZeiger(x); //Verbindung von vorherigen aktuellen Wert knüpfen
				x.setZeiger(null); //Neues Element Zeiger auf null ausrichten
				System.out.println("Show element: "+aktuell.getWert()+" show pointer "+aktuell.getZeiger().getWert());
				aktuell = x; //Neuer aktuell Wert = neues erstelltes Element
			}
		}
	}
	
	public boolean isEmpty() {
		if(anfang == null) {
			return true;
		} else {
			return false;
		}
	}
}
```
Element.java
```
public class Element {

	int wert;
	Element zeiger;

	Element(int wert) {
		this.wert = wert;
	}
	
	public int getWert() {
		return wert;
	}
	
	public void setZeiger(Element zeiger) {
		this.zeiger = zeiger;
	}
	
	public Element getZeiger() {
		return zeiger;
	}
}
```
Mein exaktes Problem ist glaube ich, dass ich das mit den Zeigern nicht ganz gerallt habe, was die Liste wohl ansich können soll, weiß ich im Grunde schon, aber die Umsetzung hapert noch ein wenig ;)

Die insert Methode der Klasse Liste z.B. scheint wohl der Hauptübeltäter zu sein, ich bin aber jetzt auch nicht der Java/OOP Profi, als dass ich sagen könnte, wo der dicke Fehler liegt.

Freue mich über jede Hilfe.

EDIT:
Die Ausgabe wäre vllt. noch interessant xD
Start new List:15
Show element: 15 show pointer 27
Show element: 27 show pointer 60
Show new order 16 show pointer 60
Show new order 28 show pointer 60
Show element: 60 show pointer 61

Es sollte aber eher so sein
Start new List:15
Show element: 15 show pointer 16
Show new order 16 show pointer 27
Show element: 27 show pointer 28
Show new order 28 show pointer 60
Show element: 60 show pointer 61

Jedoch will es irgendwie nicht oo?

Gruß,
Garlian

Beitrag zuletzt geändert: 1.3.2010 15:21:17 von garlian
Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

lima-city: Gratis werbefreier Webspace für deine eigene Homepage

21:15, 1.3.2010

garlian schrieb:

else {
	Element x = new Element(wert);
	aktuell.setZeiger(x); //Verbindung von vorherigen aktuellen Wert knüpfen
	x.setZeiger(null); //Neues Element Zeiger auf null ausrichten
	System.out.println("Show element: "+aktuell.getWert()+" show pointer "+aktuell.getZeiger().getWert());
	aktuell = x; //Neuer aktuell Wert = neues erstelltes Element
}

Selbstverständlich wird ein neues Element dank fehlender Schleife oder Rekursion entweder an die erste Stelle oder (wenn es schon eine erste Stelle gibt) an die zweite Stelle gestellt.
So wie ich das verstehe willst du aber, dass die Elemente in der Liste geordnet sind.
Ich gebe dir eine Hilfestellung (rekursiv

und nicht getestet :-(

)

public void insert (int wert) {
	if (isEmpty) {
		Element x = new Element (wert);
		anfang = x;
		aktuell = x;
	} else {
		anfang = neu (anfang, wert);
	}
}

private Element neu (Element z, int wert) {
	if (z == null) {
		Element x = new Element (wert);
		aktuell = x;
	} else if (z.getWert < wert) {
		z.setZeiger (neu (z.getZeiger(), wert));
	} else {
		Element x = new Element (wert);
		x.setZeiger (z.getZeiger());
		z.setZeiger (x);
		aktuell = x;
	}
}

bandi999

bandi999 hat kostenlosen Webspace.

22:52, 3.3.2010

Hi,
also abstrakte Klassen sind in Java eigentlich Klassen die nicht instanziiert werden können, sondern nur als oberstes Element einer Vererbungshierachie dienen. Ich bin mir nicht ganz sicher ob das in deiner Aufgabe auch gemeint ist. Dein Beispiel ist auf jeden Fall eine konkrete Klasse. Auch dein Hinweis auf Zeiger hat eigentlich nichts mit abstrakten Klassen zu tun. In abstrakten Klassen werden einfach einige Methoden nicht ausprogrammiert, sondern nur die Signatur vorgegeben.
Ein Programm, das einen Datentyp Liste liefern soll ergibt irgendwie keinen Sinn. Die abstakte Klasse Liste implementieren schon eher.
Daher formuliere ich die Aufgabe mal so: Erstellen sie eine verknüpfte Liste (Linked List) für integer Elemente :).

Die Idee Elemente als Wrapper für den Integer einzusetzen ist schon mal gut.
Dann hast du die insert Methode für die Liste implementiert. Dabei solltest du zunächst die möglichen Fälle untersuchen:
1.) Liste ist leer (erstes Element wird eingefügt)

if (isEmpty()) {
			anfang = x;
			aktuell = x;

2.) Eingefügtes Element ist erstes Elment in einer nicht leeren Liste (Listenanfang wird geändert)

else if (wert < anfang.getWert()) {
			x.setZeiger(anfang);
			anfang = x;
			aktuell = x;

3.) Element ist innerhalb der Liste einzufügen (richtige Stelle ermitteln)
4.) Element ist letztes Element (an Liste anhängen und für Abschluss sorgen)

else {
			aktuell = anfang;
			while (!(aktuell.getZeiger() == null)
					&& (wert > aktuell.getZeiger().getWert())) {
				aktuell = aktuell.getZeiger();
			}
			if (aktuell.getZeiger() == null)
				aktuell.setZeiger(x);
			else {
				x.setZeiger(aktuell.getZeiger());
				aktuell.setZeiger(x);
			}

Im letzten Code Schnipsel wird die Liste durchlaufen, bis die Liste zu Ende ist, oder bis ein Wert in der Liste gefunden wird, welcher größer ist als der einzufügende. Dann wird das Element eben angehängt (beim Erzeugen des Elements wird der Zeiger bereits auf null gesetzt und zeigt somit das neue Listenende an) oder vor dem größeren Wert eingefügt.

Das war's schon :), zumindest mit insert.
Wahrscheinlich willst du ja auch Elemente ausgeben oder auf das Vorhandensein eines Elementes prüfen oder Elemente löschen oder ..... Vielleicht war ja auch das die Aufgabe, dass du dir einfach nur überlegen sollst welche Funktionen in so einer Liste sinnvoll wären und die Implementierung gar nicht gefragt ist (deshalb abstrakt)?
Hier noch das Gesamtwerk:

public class Liste {
	Element anfang, aktuell = null;

	public void insert(int wert) {
		Element x = new Element(wert);
		if (isEmpty()) {
			anfang = x;
			aktuell = x;
			System.out.println("Start new List: **" + anfang.getWert()+"**");
		} else if (wert < anfang.getWert()) {
			x.setZeiger(anfang);
			anfang = x;
			aktuell = x;
		} else {
			aktuell = anfang;
			while (!(aktuell.getZeiger() == null)
					&& (wert > aktuell.getZeiger().getWert())) {
				aktuell = aktuell.getZeiger();
			}
			if (aktuell.getZeiger() == null)
				aktuell.setZeiger(x);
			else {
				x.setZeiger(aktuell.getZeiger());
				aktuell.setZeiger(x);
			}
		}
		aktuell = anfang;
		System.out.println("Show list order:");
		if (anfang == x)
			System.out.print("**" + anfang.getWert() + "** ");
		else
			System.out.print(anfang.getWert() + " ");
		while (!(aktuell.getZeiger() == null)) {
			aktuell = aktuell.getZeiger();
			if (aktuell == x)
				System.out.print("**" + aktuell.getWert() + "** ");
			else
				System.out.print(aktuell.getWert() + " ");
		}
		System.out.println();
		aktuell = x; // Neuer aktuell Wert = neues erstelltes Element
	}

	public boolean isEmpty() {
		if (anfang == null) {
			return true;
		} else {
			return false;
		}
	}

	public class Element {
		int wert;
		Element zeiger = null;

		Element(int wert) {
			this.wert = wert;
		}

		public int getWert() {
			return wert;
		}

		public void setZeiger(Element zeiger) {
			this.zeiger = zeiger;
		}

		public Element getZeiger() {
			return zeiger;
		}
	}

	public static void main(String args[]) {
		Liste a1 = new Liste();
		a1.insert(15);
		a1.insert(27);
		a1.insert(60);
		a1.insert(16);
		a1.insert(28);
		a1.insert(3);
		a1.insert(61);
		
	}
}

sadweb

sadweb hat kostenlosen Webspace.

16:09, 26.7.2010

Hey,

Ich hab mir jetzt nicht alles angeguckt, aber da es anscheinend hier einige Missverständnisse zum Thema Abstrakt gab, will ich wenigstens da mal helfen:

In der Aufgabenstellung kam das Wort abstrakt vor. In Java gibt es 2 große Bereiche die hier anscheinend verwechselt wurden:

Abstrakte Klassen:

Eine Klasse die nicht direkt Instanziert werden kann.
Von ihr kann geerbt werden und es können Methoden von ihr Überschrieben werden.
Dienen zum Zusammenfassen von Unterschiedlichen Objekttypen mit gemeinsamen Merkmalen.

z.B. : Abstract Class Auto ( Atribute: Fahrer, Kofferraum, Farbe)

Class LKW erbt von Auto --> (hat die Attris von Auto + Ladefläche , Beifahrer... etc
Class PKW "" (Attris: Anzahl Mitfahrer etc...)

Abstrakte Datentypen

Wenn man eine Allgemeine Liste schreiben will, dann soll diese ja nicht nur dazu Dienen Integerwerte reinlegen zu können sondern vielleicht auch mal Strings o.ä. Daher nimmt man als Listentyp Element da dies sowohl Integer als auch String oder irgendein Objekt sein kann.

Ich hoffe die erklärung dient irgendwem :)
Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

lima-city: Gratis werbefreier Webspace für deine eigene Homepage

Dir gefällt dieses Thema?

Über lima-city

lima-city bietet dir kostenlosen und werbefreien Speicherplatz für Deine Homepage. Sofort anmelden und direkt loslegen mit Webspace, PHP, Datenbanken, günstigen Domains und einer tollen Community!

kostenloser Webspace werbefrei: lima-city