www.r-krell.de
Webangebot für Schule und Unterricht, Software, Fotovoltaik und mehr

Willkommen/Übersicht  >  Informatik  >  Informatik mit Java, Teil e)   >  ADT-Test 2014-2016
oder Willkommen/Übersicht  >  Informatik  >  Informatik-Klausuren   >  ADT-Test 2014-2016


Testprogramm für die
linearen abstrakten Datentypen
Queue (Schlange), Stack (Keller) und List (Liste)
laut Zentralabitur-Vorgaben

In einem Extra-Fenster erscheint das Testprogramm
(eventuell zunächst hinter dieser Webseite -- ggf. unten auf der Taskleiste auf die Java-Tasse klicken!)
Achtung: Entsprechend den Vorgaben (s.u.) wird nicht gemeldet, ob eine Operation gelingt
oder fehlschlägt. Die Ausgabe "null" steht für ein nicht vorhandenes Element; "" für leeren Text.

Das Ausführen von Java-Applets muss erlaubt sein bzw. erlaubt werden.
Erscheint eine Warnung bzw. eine Nachfrage, bitte geblockte Inhalte zulassen.
Es muss die
Java JRE der Version (1.)5 oder neuer installiert sein.

Applet geht nicht oder wird blockiert? - Gründe, Abhilfe und alle Downloads (in neuem Tab) - nur Queue_Stack_List_im_Abitur2014-2016 (r-krell.de).jar (25 kB) herunter laden



Komplette Quelltexte weiter unten auf dieser Seite!



Für das Zentralabitur im Informatik-Leistungskurs im Bildungsgang nach Anlage D21 der Berufskollegs in Nordrhein-Westfalen wird vorgeschrieben, wie die drei wichtigen linearen Datentypen und die darauf operierenden Standardmethoden heißen und was sie genau tun sollen. In den nachfolgenden Quelltexten sind diese Vorgaben als rote Kommentare zu finden (die gleichlautenden Quellen sind - wenn auch in leicht verändertem Layout - jeweils auf den Seiten 10 bis 13 der Vorgaben_2014, Vorgaben_2015 und der Vorgaben_2016 des Berufskollegs bzw. Beruflichen Gymnasiums sowie auf den Seiten 8 bis 11 in den Materialien zu den zentralen Abiturprüfungen im Fach Informatik ab 2012... des Gymnasiums in NRW zu finden).

Bei Keller und Schlange (jetzt: Stack und Queue) wird nahe am weit verbreiteten Standard implementiert (und man könnte höchstens aus Bequemlichkeit wünschen, dass pop oder dequeue die gelöschten Elemente auch zurückgeben, und - damit man sich nicht für jeden Speichertyp einen eigenen Namen für die Löschmethode merken muss - beidesmal gleich heißen: raus).

Deutlich schlechter ist die Beschreibung der Liste (jetzt List) gelungen: Hier wurden Vorgaben getroffen bzw. aus den gymnasialen Vorschriften in NRW übernommen, die Fehler der Vorjahre durch quick&dirty work-arounds bzw. Hinzufügen weiterer Methoden beheben, statt die ursprünglichen Methoden konsequent und konsistent zu verbessern. Im folgenden Quelltext finden Sie in den grünen Kommentaren Hinweise hierzu.
Da einige Fehler abgefangen werden, wären außerdem (Miss-)Erfolgsmeldungen sinnvoll - beispielsweise, wenn die mit viel Mühe eingetippten Elemente bei insert gar nicht eingefügt werden, weil man vergessen hatte, auf toFirst zu drücken und daher noch kein aktuelles Element gesetzt wurde (was leider eben nicht automatisch geschieht).

Auch wenn ich glaube, mit meiner im Kapitel 3 auf der Seite "Informatik mit Java, Teil e)" gezeigten Version eine deutlich besser konzipierte Liste vorlegen zu können, muss ich natürlich meine Schülerinnen und Schüler auf das Zentralabitur und die dort geltenden Regelungen vorbereiten. Deswegen wurde im Unterricht das hier vorgestellte Programm erarbeitet, das eine Implementation gemäß den Abitur-Vorgaben enthält und Tests im Umgang mit den geforderten abstrakten Datentypen ermöglicht.

Allerding ist es wohl nicht mehr zeitgemäß, Knoten und Speicher immer nur für den allgemeinsten Datentyp Object zu definieren und somit auf eine genauere Typprüfung zu verzichten (wie ich es 2003/2004 vor zehn Jahren auch noch gemacht hatte). Seit der Version 1.5 erlaubt Java die einfache Verwendung generischer Datentypen, die auch genutzt werden sollte: Die zu meinem Arbeitsblatt 'Keller und Javaquelltexte zu Keller und Schlangen' bei den Informatik-Klausuren zum Download angebotenen Quelltexte Q1_Keller&Schlange.zip (260 kB mit Testoberfläche und Bildern) zeigen, wie einfach die Typisierung der Speicher ist. Und auch das auf meiner zweiten Software-Engineering-Seite SWE-2 vorgestellte Spiel-Applet 'Rot & Schwarz' nutzt und zeigt selbstverständlich eine typisierte Schlange (jeweils mit meinen Methodennamen). Die zentralen Anforderungen bleiben leider hinter dem Stand der Technik zurück.

Der komplette in meinem Unterricht gemeinsam mit den Schülerinnen und Schülern entwickelte Quelltext nach den Zentralabitur-Vorgaben folgt getrennt für die fünf beteiligten Klassen:

Alternative, von mir nicht getestete Java-Programmtexte zu den gleichen Vorgaben finden sich im Unterordner ..\abiturklassen\listenklassen in den (gezippten) Quelltexte[n] zu den Materialien ab 2012 - Java-Version 1.2 (auch erreichbar über die Informatik-Zentralabitur-Seite des Gymnasiums).


zum Seitenanfang / zum Seitenende

Gemeinsame grafische Oberfläche

Die grafische Oberfläche wurde mit dem GUI-Builder des Javaeditors erstellt. Nur die .._ActionPerformed-Methoden der Schaltflächen mussten noch von Hand ausgefüllt werden.

Bildschirmfoto Programmerstellung im Java-Editor

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

/**
  * Projekt "ADT14"
  * Testoberfläche für die drei abstrakten Datentypen Queue, Stack und List
  * wie für das Zentralabitur im Berufskolleg verlangt.
  *
  * @version  1.4 from 13.01.2014/18.01.2014 und 11.3.2014
  * @author   R. Krell für IF Q2-M
  * @homepage http://www.r-krell.de
  *
  */

public class ADT14_Gui extends JFrame {
  
// Anfang Attribute
  Queue queue = null;
  Stack stack = 
null;
  List  list  = 
null;
  
  
private JLabel jLbUeberschrift = new JLabel();
  
private JLabel jLbEingabe = new JLabel();
  
private JTextField jTfEingabe = new JTextField();
  
private JLabel jLbQ = new JLabel();
  
private JButton jBtQnew = new JButton();
  
private JButton jBtQenq = new JButton();
  
private JButton jBtQemp = new JButton();
  
private JButton jBtQfront = new JButton();
  
private JButton jBtQdeq = new JButton();
  
private JLabel jLbS = new JLabel();
  
private JButton jBtSnew = new JButton();
  
private JButton jBtSpush = new JButton();
  
private JButton jBtSemp = new JButton();
  
private JButton jBtStop = new JButton();
  
private JButton jBtSpop = new JButton();
  
private JLabel jLbL = new JLabel();
  
private JButton jBtLnew = new JButton();
  
private JButton jBtLins = new JButton();
  
private JButton jBtLset = new JButton();
  
private JButton jBtLapp = new JButton();
  
private JButton jBtLemp = new JButton();
  
private JButton jBtLhas = new JButton();
  
private JButton jBtLget = new JButton();
  
private JButton jBtLrem = new JButton();
  
private JButton jBtLfirst = new JButton();
  
private JButton jBtLlast = new JButton();
  
private JButton jBtLconc = new JButton();
  
private JButton jBtLnext = new JButton();
  
private JTextArea jTaAusgabe = new JTextArea("");
    
private JScrollPane jTaAusgabeScrollPane = new JScrollPane(jTaAusgabe);
  
private ButtonGroup buttonGroup1 = new ButtonGroup();
  
private JRadioButton jRBabc = new JRadioButton();
  
private JRadioButton jRBselbst = new JRadioButton();
  
private JButton jBtLKontrolle = new JButton();
  
// Ende Attribute

  public ADT14_Gui (String title) {
    
super (title);
    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    
int frameWidth = 889
    
int frameHeight = 555;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    
int x = (d.width - getSize().width) / 2;
    
int y = (d.height - getSize().height) / 2;
    setLocation(x, y);
    Container cp = getContentPane();
    cp.setLayout(
null);
    
// Anfang Komponenten
    jLbUeberschrift.setBounds(16875333);
    jLbUeberschrift.setText(
"Abstrakte dynamische Datentypen bzw. -speicher (nach Vorgaben des Zentralabiturs 2014)");
    jLbUeberschrift.setFont(
new Font("@Arial Unicode MS", Font.BOLD, 16));
    cp.add(jLbUeberschrift);
    jLbEingabe.setBounds(
164811020);
    jLbEingabe.setText(
"Eingabe:");
    jLbEingabe.setEnabled(
false);
    cp.add(jLbEingabe);
    jTfEingabe.setBounds(
964851325);
    jTfEingabe.setEnabled(
false);
    cp.add(jTfEingabe);
    jLbQ.setBounds(
16885728);
    jLbQ.setText(
"Schlange");
    jLbQ.setEnabled(
false);
    cp.add(jLbQ);
    jBtQnew.setBounds(
96888925);
    jBtQnew.setText(
"new Queue");
    jBtQnew.setMargin(
new Insets(2222));
    jBtQnew.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtQnew_ActionPerformed(evt);
      }
    });
    jBtQnew.setToolTipText(
"Erzeuge");
    cp.add(jBtQnew);
    jBtQenq.setBounds(
216888125);
    jBtQenq.setText(
"enqueue");
    jBtQenq.setMargin(
new Insets(2222));
    jBtQenq.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtQenq_ActionPerformed(evt);
      }
    });
    jBtQenq.setToolTipText(
"rein (als letztes/hinterstes Element)");
    jBtQenq.setEnabled(
false);
    cp.add(jBtQenq);
    jBtQemp.setBounds(
320888125);
    jBtQemp.setText(
"isEmpty?");
    jBtQemp.setMargin(
new Insets(2222));
    jBtQemp.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtQemp_ActionPerformed(evt);
      }
    });
    jBtQemp.setToolTipText(
"istLeer");
    jBtQemp.setEnabled(
false);
    cp.add(jBtQemp);
    jBtQfront.setBounds(
424888125);
    jBtQfront.setText(
"front");
    jBtQfront.setMargin(
new Insets(2222));
    jBtQfront.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtQfront_ActionPerformed(evt);
      }
    });
    jBtQfront.setToolTipText(
"zeige1 (zeige vorderstes Element)");
    jBtQfront.setEnabled(
false);
    cp.add(jBtQfront);
    jBtQdeq.setBounds(
528888125);
    jBtQdeq.setText(
"dequeue");
    jBtQdeq.setMargin(
new Insets(2222));
    jBtQdeq.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtQdeq_ActionPerformed(evt);
      }
    });
    jBtQdeq.setToolTipText(
"raus (vorderstes Element löschen)");
    jBtQdeq.setEnabled(
false);
    cp.add(jBtQdeq);
    jLbS.setBounds(
161286725);
    jLbS.setText(
"Keller");
    jLbS.setEnabled(
false);
    cp.add(jLbS);
    jBtSnew.setBounds(
961288925);
    jBtSnew.setText(
"new Stack");
    jBtSnew.setMargin(
new Insets(2222));
    jBtSnew.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtSnew_ActionPerformed(evt);
      }
    });
    jBtSnew.setToolTipText(
"neuer leerer Keller");
    cp.add(jBtSnew);
    jBtSpush.setBounds(
2161288125);
    jBtSpush.setText(
"push");
    jBtSpush.setMargin(
new Insets(2222));
    jBtSpush.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtSpush_ActionPerformed(evt);
      }
    });
    jBtSpush.setToolTipText(
"rein (als oberstes Element)");
    jBtSpush.setEnabled(
false);
    cp.add(jBtSpush);
    jBtSemp.setBounds(
3201288125);
    jBtSemp.setText(
"isEmpty?");
    jBtSemp.setMargin(
new Insets(2222));
    jBtSemp.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtSemp_ActionPerformed(evt);
      }
    });
    jBtSemp.setToolTipText(
"istLeer");
    jBtSemp.setEnabled(
false);
    cp.add(jBtSemp);
    jBtStop.setBounds(
4241288125);
    jBtStop.setText(
"top");
    jBtStop.setMargin(
new Insets(2222));
    jBtStop.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtStop_ActionPerformed(evt);
      }
    });
    jBtStop.setToolTipText(
"zeige1 (auch: peek) (zeige oberstes Element)");
    jBtStop.setEnabled(
false);
    cp.add(jBtStop);
    jBtSpop.setBounds(
5281288125);
    jBtSpop.setText(
"pop");
    jBtSpop.setMargin(
new Insets(2222));
    jBtSpop.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtSpop_ActionPerformed(evt);
      }
    });
    jBtSpop.setToolTipText(
"raus (oberstes Element löschen)");
    jBtSpop.setEnabled(
false);
    cp.add(jBtSpop);
    jLbL.setBounds(
161687525);
    jLbL.setText(
"Liste");
    jLbL.setEnabled(
false);
    cp.add(jLbL);
    jBtLnew.setBounds(
961688925);
    jBtLnew.setText(
"new List");
    jBtLnew.setMargin(
new Insets(2222));
    jBtLnew.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLnew_ActionPerformed(evt);
      }
    });
    jBtLnew.setToolTipText(
"erzeuge neue leere Liste");
    cp.add(jBtLnew);
    jBtLins.setBounds(
2161688125);
    jBtLins.setText(
"insert");
    jBtLins.setMargin(
new Insets(2222));
    jBtLins.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLins_ActionPerformed(evt);
      }
    });
    jBtLins.setToolTipText(
"rein (vorm aktuellen Element)");
    jBtLins.setEnabled(
false);
    cp.add(jBtLins);
    jBtLset.setBounds(
2242007325);
    jBtLset.setText(
"setObject");
    jBtLset.setMargin(
new Insets(2222));
    jBtLset.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLset_ActionPerformed(evt);
      }
    });
    jBtLset.setToolTipText(
"ersetzt aktuelles Element");
    jBtLset.setEnabled(
false);
    cp.add(jBtLset);
    jBtLapp.setBounds(
2242327325);
    jBtLapp.setText(
"append");
    jBtLapp.setMargin(
new Insets(2222));
    jBtLapp.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLapp_ActionPerformed(evt);
      }
    });
    jBtLapp.setToolTipText(
"hinten dran (egal, was aktuell ist)");
    jBtLapp.setEnabled(
false);
    cp.add(jBtLapp);
    jBtLemp.setBounds(
3201688125);
    jBtLemp.setText(
"isEmpty?");
    jBtLemp.setMargin(
new Insets(2222));
    jBtLemp.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLemp_ActionPerformed(evt);
      }
    });
    jBtLemp.setToolTipText(
"istLeer");
    jBtLemp.setEnabled(
false);
    cp.add(jBtLemp);
    jBtLget.setBounds(
4241688125);
    jBtLget.setText(
"getObject");
    jBtLget.setMargin(
new Insets(2222));
    jBtLget.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLget_ActionPerformed(evt);
      }
    });
    jBtLget.setToolTipText(
"zeige1 (zeige aktuelles Element)");
    jBtLget.setEnabled(
false);
    cp.add(jBtLget);
    jBtLrem.setBounds(
5281688125);
    jBtLrem.setText(
"remove");
    jBtLrem.setMargin(
new Insets(2222));
    jBtLrem.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLrem_ActionPerformed(evt);
      }
    });
    jBtLrem.setToolTipText(
"raus (aktuelles El. löschen)");
    jBtLrem.setEnabled(
false);
    cp.add(jBtLrem);
    jBtLfirst.setBounds(
6402008725);
    jBtLfirst.setText(
"toFirst");
    jBtLfirst.setMargin(
new Insets(2222));
    jBtLfirst.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLfirst_ActionPerformed(evt);
      }
    });
    jBtLfirst.setToolTipText(
"macht erstes Element aktuell");
    jBtLfirst.setEnabled(
false);
    cp.add(jBtLfirst);
    jBtLlast.setBounds(
6402328725);
    jBtLlast.setText(
"toLast");
    jBtLlast.setMargin(
new Insets(2222));
    jBtLlast.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLlast_ActionPerformed(evt);
      }
    });
    jBtLlast.setToolTipText(
"macht letztes Element aktuell");
    jBtLlast.setEnabled(
false);
    cp.add(jBtLlast);
    jBtLhas.setBounds(
6401688725);
    jBtLhas.setText(
"hasAccess?");
    jBtLhas.setMargin(
new Insets(2222));
    jBtLhas.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLhas_ActionPerformed(evt);
      }
    });
    jBtLhas.setToolTipText(
"gibt es ein aktuelles Element?");
    jBtLhas.setEnabled(
false);
    cp.add(jBtLhas);
    jBtLnext.setBounds(
6402648725);
    jBtLnext.setText(
"next");
    jBtLnext.setMargin(
new Insets(2222));
    jBtLnext.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLnext_ActionPerformed(evt);
      }
    });
    jBtLnext.setToolTipText(
"macht nächstes El. aktuell");
    jBtLnext.setEnabled(
false);
    cp.add(jBtLnext);
    jBtLconc.setBounds(
75223211325);
    jBtLconc.setText(
"concat");
    jBtLconc.setMargin(
new Insets(2222));
    jBtLconc.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLconc_ActionPerformed(evt);
      }
    });
    jBtLconc.setToolTipText(
"hängt 2. Liste an die aktuelle hinten dran");
    jBtLconc.setEnabled(
false);
    cp.add(jBtLconc);

    jTaAusgabeScrollPane.setBounds(
16296849217);
    cp.add(jTaAusgabeScrollPane);

    jRBabc.setBounds(
75217610020);
    jRBabc.setText(
"\"a\"-\"b\"-\"c\"");
    jRBabc.setOpaque(
false);
    jRBabc.setToolTipText(
"hinten Liste \"a\"-\"b\"-\"c\" dran");
    buttonGroup1.add(jRBabc);

    cp.add(jRBabc);
    jRBselbst.setBounds(
75220012420);
    jRBselbst.setText(
"2 x akt. El.");
    jRBselbst.setOpaque(
false);
    jRBselbst.setToolTipText(
"gleiche Liste nochmal anhängen");
    buttonGroup1.add(jRBselbst);

    cp.add(jRBselbst);
    jBtLKontrolle.setBounds(
9626451325);
    jBtLKontrolle.setText(
"Ausgabe der gesamten Datenstruktur zur Kontrolle");
    jBtLKontrolle.setMargin(
new Insets(2222));
    jBtLKontrolle.addActionListener(
new ActionListener() { 
      
public void actionPerformed(ActionEvent evt) { 
        jBtLKontrolle_ActionPerformed(evt);
      }
    });
    jBtLKontrolle.setEnabled(
true);
    jBtLKontrolle.setToolTipText(
"Darstellung des vollständigen Datenspeichers (alle Elemente)");
    cp.add(jBtLKontrolle);
    
// Ende Komponenten
    setResizable(false);
    setVisible(
true);
  }

  
// Anfang Methoden
  public void jBtQnew_ActionPerformed(ActionEvent evt) {
    jLbEingabe.setEnabled(
true);
    jTfEingabe.setEnabled(
true);
    jLbQ.setEnabled(
true);
    jBtQnew.setEnabled(
false);
    jBtSnew.setEnabled(
false);
    jBtLnew.setEnabled(
false);
    jBtQenq.setEnabled(
true);
    jBtQemp.setEnabled(
true);
    jBtQfront.setEnabled(
true);
    jBtQdeq.setEnabled(
true);
    
    queue = 
new Queue();
    jTaAusgabe.setText(
"Neue leere Schlange (Queue) wurde erzeugt\n");
  }

  
public void jBtQenq_ActionPerformed(ActionEvent evt) {
    String neu = jTfEingabe.getText();
    queue.enqueue(neu);
    jTaAusgabe.append(
"\""+neu+"\" hinten an Schlange dran\n");    
  }

  
public void jBtQemp_ActionPerformed(ActionEvent evt) {
    
if (queue.isEmpty()) 
    {
      jTaAusgabe.append(
"Die Schlange ist z.Z. leer\n");
    }
    
else  
    {
      jTaAusgabe.append(
"Die Schlange ist z.Z. nicht leer\n");
    }    
  }

  
public void jBtQfront_ActionPerformed(ActionEvent evt) {
    String vorne = (String) queue.front();
    jTaAusgabe.append(
"Vorne in der Schlange steht \""+vorne+"\"\n");
  }

  
public void jBtQdeq_ActionPerformed(ActionEvent evt) {
    queue.dequeue();
    jTaAusgabe.append(
"Das vorderste Element wurde (soweit vorhanden) unbesehen aus der Schlange entfernt\n");
  }

  
public void jBtSnew_ActionPerformed(ActionEvent evt) {
    jLbEingabe.setEnabled(
true);
    jTfEingabe.setEnabled(
true);
    jLbS.setEnabled(
true);
    jBtQnew.setEnabled(
false);
    jBtSnew.setEnabled(
false);
    jBtLnew.setEnabled(
false);
    jBtSpush.setEnabled(
true);
    jBtSemp.setEnabled(
true);
    jBtStop.setEnabled(
true);
    jBtSpop.setEnabled(
true);
    
    stack = 
new Stack();
    jTaAusgabe.setText(
"Neuer leerer Keller (Stack) wurde erzeugt\n");
  }

  
public void jBtSpush_ActionPerformed(ActionEvent evt) {
    String neu = jTfEingabe.getText();
    stack.push(neu);
    jTaAusgabe.append(
"\""+neu+"\" oben auf Keller drauf\n");
  }

  
public void jBtSemp_ActionPerformed(ActionEvent evt) {
    
if (stack.isEmpty()) 
    {
      jTaAusgabe.append(
"Der Keller ist z.Z. leer\n");
    }
    
else  
    {
      jTaAusgabe.append(
"Der Keller ist z.Z. nicht leer\n");
    }  
  }

  
public void jBtStop_ActionPerformed(ActionEvent evt) {
    String oben = (String) stack.top();
    jTaAusgabe.append(
"Oben auf dem Keller liegt \""+oben+"\"\n");    // TODO hier Quelltext einfügen
  }

  
public void jBtSpop_ActionPerformed(ActionEvent evt) {
    stack.pop();
    jTaAusgabe.append(
"Das oberste Element wurde (soweit vorhanden) unbesehen aus dem Keller entfernt\n");
  }

  
public void jBtLnew_ActionPerformed(ActionEvent evt) {
    jLbEingabe.setEnabled(
true);
    jTfEingabe.setEnabled(
true);
    jLbL.setEnabled(
true);
    jBtQnew.setEnabled(
false);
    jBtSnew.setEnabled(
false);
    jBtLnew.setEnabled(
false);
    jBtLins.setEnabled(
true);
    jBtLset.setEnabled(
true);
    jBtLapp.setEnabled(
true);
    jBtLemp.setEnabled(
true);
    jBtLhas.setEnabled(
true);
    jBtLget.setEnabled(
true);
    jBtLrem.setEnabled(
true);
    jBtLfirst.setEnabled(
true);
    jBtLlast.setEnabled(
true);
    jBtLnext.setEnabled(
true);
    jBtLconc.setEnabled(
true);
    
    list = 
new List();
    jTaAusgabe.setText(
"Neue leere Liste (List) wurde erzeugt\n");
  }

  
public void jBtLins_ActionPerformed(ActionEvent evt) {
    String neu = jTfEingabe.getText();
    list.insert(neu);
    jTaAusgabe.append(
"\""+neu+"\" vor aktuellem Element in die Liste rein (nur falls es ein aktuelles Element gab)\n");
  }

  
public void jBtLset_ActionPerformed(ActionEvent evt) {
    String neu = jTfEingabe.getText();
    list.setObject(neu);
    jTaAusgabe.append(
"\""+neu+"\" ersetzt aktuelles Element in die Liste (nur falls es ein aktuelles Element gab)\n");
  }

  
public void jBtLapp_ActionPerformed(ActionEvent evt) {
    String neu = jTfEingabe.getText();
    list.append(neu);
    jTaAusgabe.append(
"\""+neu+"\" hinten an Liste dran; aktuelles Element unverändert\n");
  }

  
public void jBtLemp_ActionPerformed(ActionEvent evt) {
    
if (list.isEmpty()) 
    {
      jTaAusgabe.append(
"Der Liste ist z.Z. leer\n");
    }
    
else  
    {
      jTaAusgabe.append(
"Der Liste ist z.Z. nicht leer\n");
    }  
  }

  
public void jBtLhas_ActionPerformed(ActionEvent evt) {
    
if (list.hasAccess()) 
    {
      jTaAusgabe.append(
"Es gibt ein aktuelles Element in der Liste\n");
    }
    
else  
    {
      jTaAusgabe.append(
"In der Liste ist z.Z. kein(!) Element aktuell\n");
    }  
  }

  
public void jBtLget_ActionPerformed(ActionEvent evt) {
    jTaAusgabe.append(
"Aktuelles Element der Liste ist z.Z. \""+(String)(list.getObject())+"\"\n");
  }

  
public void jBtLrem_ActionPerformed(ActionEvent evt) {
    list.remove();
    jTaAusgabe.append(
"Das aktuelle Element der Liste wurde (falls vorhanden) unbesehen entfernt\n");
  }

  
public void jBtLfirst_ActionPerformed(ActionEvent evt) {
    list.toFirst();
    jTaAusgabe.append(
"Das erste Listenelement wurde zum neuen aktuellen Element\n");
  }

  
public void jBtLlast_ActionPerformed(ActionEvent evt) {
    list.toLast();
    jTaAusgabe.append(
"Das letzte Listenelement wurde zum neuen aktuellen Element\n");
  }

  
public void jBtLnext_ActionPerformed(ActionEvent evt) {
    list.next();
    jTaAusgabe.append(
"Der Nachfolger des aktuellen Listenelement wurde aktuell\n");
  }
    
  
public void jBtLconc_ActionPerformed(ActionEvent evt) {
    
if (buttonGroup1_getSelectedRadioButtonLabel().equals(""))
    {
      jTaAusgabe.append(
"Keine Liste zum Anhängen gewählt -- nichts passiert\n");
    }
    
else
    {
      List pList = 
null;
      
if (buttonGroup1_getSelectedRadioButtonLabel().equals("2 x akt. El."))
      {
        pList = 
new List();
        pList.append(list.getObject()); pList.append(list.getObject());
      }
      
else
      {
        pList = 
new List();
        pList.append(
"a"); pList.append("b"); pList.append("c"); 
      }
      list.concat (pList);
      jTaAusgabe.append(
"Die gewünschte Liste pList wurde angehängt; danach pList.isEmpty() = "+pList.isEmpty()+"\n");     
    } 
// end of if
  }

  
public String buttonGroup1_getSelectedRadioButtonLabel() {
    
for (java.util.Enumeration<AbstractButton> e = buttonGroup1.getElements(); e.hasMoreElements();) {
      AbstractButton b = e.nextElement();
      
if (b.isSelected()) return b.getText();
    }
    
return "";
  }

  
public void jBtLKontrolle_ActionPerformed(ActionEvent evt) {
    
if (queue != null)
    {
      jTaAusgabe.append(queue.kontrollAusgabe());
    }
    
else if (stack != null)
      {
        jTaAusgabe.append(stack.kontrollAusgabe());
      }
      
else if (list != null)
        {
           jTaAusgabe.append(list.kontrollAusgabe());
        }
        
else 
          {
            jTaAusgabe.append(
"Noch kein Datenspeicher gewählt bzw. erzeugt!\n");
          }
  } 
// end of jBtLKontrolle_ActionPerformed

  // Ende Methoden

  public static void main(String[] args) {
    
new ADT14_Gui("Abstrakte dynamische Datentypen ADT 2014");
  }
}


zum Seitenanfang / zum Seitenende

Gemeinsamer Hilfstyp Knoten

Voraussetzung für die dynamische Implementation aller drei Speichertypen sind Knoten, die einerseits jeweils ein Element als Inhalt aufnehmen und andererseits einen Verweis auf den nächsten Knoten enthalten. Alle drei Speicheraten benutzen den gleichen, einheitlichen Knotentyp Node.



// Teil des Projekts "ADT14" für Queue, Stack und List
// R. Krell, 15.1.2014 - für IF Q2M - www.r-krell.de

public class Node   // Knoten
{
  Object inhalt;
  Node nächster; 
  
  
public Node(Object pObject, Node naechster)
  {
    inhalt = pObject;
    nächster = naechster;
  }        
}



Die Attribute inhalt und nächster wurden extra nicht als private deklariert, um den nachfolgenden Speichern einen einfacheren Zugriff darauf zu erlauben.


zum Seitenanfang / zum Seitenende

Speichertyp Schlange (Queue)



// Teil des Projekts "ADT14" für Queue, Stack und List
// R. Krell, 15./18.1.2014 - für IF Q2M - www.r-krell.de 
// Beschreibungen 
/* ".." */ aus info_pblk_info_abivorgaben2014.pdf (S. 11) von
// http://www.standardsicherung.schulministerium.nrw.de/abitur-bk/fach.php?fach=11

// Alternativen u.a. auf http://www.r-krell.de/if-java-e.htm


/* 
"Die Klasse Queue 
Objekte der Klasse Queue (Warteschlange) verwalten beliebige Objekte nach dem 
First-In-First-Out-Prinzip, d.h., das zuerst abgelegte Objekt wird als erstes wieder 
entnommen. "
 */

public class Queue 
{
  
private Node head = null;
  
private Node tail = null;  
  
/* "Konstruktor Queue(): Eine leere Schlange wird erzeugt." - nicht extra nötig */  
   
  public boolean isEmpty()
  
/* "boolean isEmpty() 
      Die Anfrage liefert den Wert true, wenn die Schlange keine Ob-
      jekte enthält, sonst liefert sie den Wert false."
 */
  {
    
return (head==null);   
  }   
   
  
public void enqueue(Object pObject)
  
/* "void enqueue(Object pObject) 
      Das Objekt pObject wird an die Schlange angehängt. Falls 
      pObject gleich null ist, bleibt die Schlange unverändert."
 */
  {
    
if(pObject!=null)   
    {    
      Node neu = 
new Node(pObject,null);
      
if (!isEmpty()) 
      {
        tail.nächster=neu;
      }          
      
else 
      {
        head=neu;  
//!
      }
      tail=neu;   
     }
   }
   
   
public void dequeue()
   
/* "void dequeue() 
       Das erste Objekt wird aus der Schlange entfernt. Falls die 
       Schlange leer ist, wird sie nicht verändert."
 */
   {
     
if (!isEmpty()) 
     {
       head = head.nächster;
     } 
// nach Löschen des letzten Elements zeigt Schwanz irgendwo hin 
       
// -- aber egal, da isEmpty nur auf head==null abfragt
   }      
   
   
public Object front()
   
/* "Object front() 
       Die Anfrage liefert das erste Objekt der Schlange. Die Schlange 
       bleibt unverändert. Falls die Schlange leer ist, wird null zurück 
       gegeben."
 */
   {
     
if(isEmpty())
     {
       
return(null);
     }
     
else
     {
       
return(head.inhalt);
     }   
   }
  
   
  
// --- Zusatz-Methode für die Schlangenkontrolle: ---
    
  
public String kontrollAusgabe() // gibt zu Kontrollzwecken einen Text mit allen Listenelementen zurück.
  {
    String kontrolle;
    
if (isEmpty())
    {
       kontrolle = 
"Die Schlange ist leer";
    } 
    
else 
    {
       kontrolle = 
"Schlange: << kopf=";
       Node zeiger = head;
       
int nr = 0;
       
while (zeiger != null)
       { 
         nr++;
         kontrolle = kontrolle + 
" "+nr+"=\""+zeiger.inhalt+"\"";
         zeiger = zeiger.nächster;
       } // end of while 
       kontrolle = kontrolle + 
"=schwanz <<"
    }   
    
return (kontrolle+".\n");     
  }

  
}


zum Seitenanfang / zum Seitenende

Speichertyp Keller (Stack)




// Teil des Projekts "ADT14" für Queue, Stack und List
// R. Krell, 15./18.1.2014 - für IF Q2M - www.r-krell.de 
// Beschreibungen /* 
".." */ aus info_pblk_info_abivorgaben2014.pdf (S. 11f) von
// http://www.standardsicherung.schulministerium.nrw.de/abitur-bk/fach.php?fach=11

// Alternativen u.a. auf http://www.r-krell.de/if-java-e.htm


/* 
"Die Klasse Stack 
Objekte der Klasse Stack (Keller, Stapel) verwalten beliebige Objekte nach dem 
Last-In-First-Out-Prinzip, d.h., das zuletzt abgelegte Objekt wird als erstes wieder 
entnommen."
 */ 

public class Stack
{
  
private Node oben = null;               // Zeiger auf oberstes Element; anfangs null
  /* "Konstruktor Stack(): Ein leerer Stapel wird erzeugt." - nicht extra nötig */ 
  
  
public boolean isEmpty()                       
  
/* "boolean isEmpty() 
      Die Anfrage liefert den Wert true, wenn der Stapel keine Objekte 
      enthält, sonst liefert sie den Wert false."
 */                                                                                    
  {
    
return (oben == null);
  }

  
public void push (Object pObject) 
  
/* "void push(Object pObject) 
      Das Objekt pObject wird oben auf den Stapel gelegt. Falls pOb-
      ject gleich null ist, bleibt der Stapel unverändert."
 */
  {
    
if (pObject!= null
    {
      oben = 
new Node (pObject, oben);
    }
    
  }
   
  
public void pop()   
  
/* "void pop() 
      Das zuletzt eingefügte Objekt wird von dem Stapel entfernt. Falls 
      der Stapel leer ist, bleibt er unverändert."
 */ 
  {  
    
if (oben!= null
    {
      oben = oben.nächster; 
    } 
  }
  
  
public Object top() 
  
/* "Object top() 
      Die Anfrage liefert das oberste Stapelobjekt. Der Stapel bleibt 
      unverändert. Falls der Stapel leer ist, wird null zurück gegeben."
 */  
  {
    
if(oben!=null)
    {
      
return (oben.inhalt);
    }
    
else
    {
      
return (null);
    }    
  }

  
  
// --- Zusatz-Methode für die Kellerkontrolle: ---
    
  public String kontrollAusgabe() // gibt zu Kontrollzwecken einen Text mit allen Listenelementen zurück.
  {
    String kontrolle;
    
if (isEmpty())
    {
       kontrolle = 
"Der Keller ist leer";
    } 
    
else 
    {
       kontrolle = 
"Keller: <> oben=";
       Node zeiger = oben;
       
int nr = 0;
       
while (zeiger != null)
       { 
         nr++;
         kontrolle = kontrolle + 
" "+nr+"=\""+zeiger.inhalt+"\"";
         zeiger = zeiger.nächster;
       } 
// end of while  
    }   
    
return (kontrolle+".\n");     
  }    

}




zum Seitenanfang / zum Seitenende

Speichertyp Liste (List)

Die bedauerlichen Unzulänglichkeiten der Liste habe ich (unter Angabe einer besseren Alternative) oben schon erwähnt. Meine grünen Kommentare im Text geben detailliertere Auskunft:


// Teil des Projekts "ADT14" für Queue, Stack und List
// R. Krell, 15./18.1.2014 und 11.3.2014 - für IF Q2M - www.r-krell.de 
// Beschreibungen /* 
".." */ aus info_pblk_info_abivorgaben2014.pdf (S. 12f) von
// http://www.standardsicherung.schulministerium.nrw.de/abitur-bk/fach.php?fach=11

// Alternativen u.a. auf http://www.r-krell.de/if-java-e.htm


/* 
"Die Klasse List 
Objekte der Klasse List verwalten beliebig viele, linear angeordnete Objekte. Auf 
höchstens ein Listenobjekt, aktuelles Objekt genannt, kann jeweils zugegriffen wer-
den. Wenn eine Liste leer ist, vollständig durchlaufen wurde oder das aktuelle Objekt 
am Ende der Liste gelöscht wurde, gibt es kein aktuelles Objekt. Das erste oder das 
letzte Objekt einer Liste können durch einen Auftrag zum aktuellen Objekt gemacht 
werden. Außerdem kann das dem aktuellen Objekt folgende Listenobjekt zum neuen 
aktuellen Objekt werden. 
Das aktuelle Objekt kann gelesen, verändert oder gelöscht werden. Außerdem kann 
vor dem aktuellen Objekt ein Listenobjekt eingefügt werden."
 */ 

// Anmerkung: Die Klasse ist recht unglücklich konstruiert! Hätte man bei hasAccess=false
// ein insert (am Ende) erlaubt, wäre append überflüssig. Ebenfalls überflüssig 
// (weil durch remove & insert ersetzbar) ist setObject, das zudem noch wegen seiner
// sprachlichen Nähe zu getObject irreführt. Drei statt einer 'rein'-Methode 
// sind zu viel! 
// Um das fragwürdige toLast in einer einfach-verketteten Liste zu verwirklichen, 
// kann zwar in den meisten Fällen ein (vor-)Ende-Zeiger den Aufwand auf einen 
// Schritt verringern; nach remove des letzten Elements muss dieser Zeiger aber 
// einmal ganz durch die Liste (Aufwand ~ Elementzahl). Deshalb sollte man besser
// auf toLast (und vorEnde) ganz verzichten, zumal es ja auch kein previous, 
// nur next gibt!
// Die concat-Methode verwundert ebenfalls, da es bei Queue und  Stack auch
// keine concat-Methode gibt.
// Auf http://www.r-krell.de/if-java-e.htm#Liste gelingt eine Liste nur mit istLeer,
// rein, raus, zeige, anDenAnfang, weiter und istAmEnde (eigentlich istHintermEnde
)
// (ähnlich isEmpty, insert, remove, getObject, toFirst, next und hasAccess).

public class List
{
  Node vorAnfang = 
new Node ("dummy"null);
  Node vorEnde = 
null;
  Node vorAktuell = 
null;
  
// Weil später vor dem aktuellen Element eingefügt wird und in einer einfach
  // verketteten Liste nicht zurück gegangen werden kann (um dort den Zeiger 
  // nächster zu verändern), muss statt eines Zeigers aufs aktuelle Element 
  // der Zeiger vorAktuell auf dessen Vorgänger zeigen. Damit toLast und toFirst 
  // schnell funktionieren, muss es entsprechende Zeiger vorEnde und vorAnfang
  // auf die entsprechenden Vorgänger geben. Damit es einen Vorgänger 
  // vorm ersten Element gibt, wird vor den Knoten mit den eigentlichen Elementen
  // ein dummy-Knoten erzeugt, der auch in der leeren Liste existiert (und statt
  // "dummy" auch den ohnehin unzugänglichen Inhalt null hätte haben können).
  
  
/* "Konstruktor List(): Eine leere Liste wird erzeugt." -- nicht extra nötig */ 
  
  
public boolean isEmpty()
  
/* "boolean isEmpty() 
      Die Anfrage liefert den Wert true, wenn die Liste keine Objekte 
      enthält, sonst liefert sie den Wert false."
 */     
  {
    
return (vorAnfang.nächster == null);
  }
  
  
public boolean hasAccess()
  
/* "boolean hasAccess() 
      Die Anfrage liefert den Wert true, wenn es ein aktuelles Objekt 
      gibt, sonst liefert sie den Wert false."
 */
  // Der eigentliche Sinn hätte sein können, dass hasAccess genau dann false liefert,
  
// wenn vorAktuell auf den Knoten mit dem letzten Listenelement zeigt (es also 
  
// kein aktuelles Element mehr gibt), sodass das Einfügen (mit insert) 'vor dem 
  
// aktuellen Element' in Wirklichkeit ganz am Ende hätte geschehen können 
  
// und append entbehrlich wird.
  
// Achtung: Hier bzw. in den hier implementierten Methoden remove, next, append
  
// und concat wird in Kauf genommen, dass nach hasAccess = false (weil das letzte 
  
// Element aktuell war und gelöscht wurde oder weil man nach dem letzten, aktuellen 
  
// Element next aufgerufen hat) bei einem späteren concat oder append automatisch 
  
// hasAccess wieder true wird, wobei das nächste neu angehängte Element aktuell 
  
// wird (weil vorAktuell auf dem bisher letzten Element bleibt). 
  
// Warum es hasAccess = false auch in anderen Fällen geben soll als bei der 
  
// Navigation mit dem aktuellen Element über das Listenende hinaus bleibt unklar
  
// und verdient daher keine Berücksichtigung! 
  
  {
    
return (vorAktuell != null && vorAktuell.nächster != null);
  }
  
  
public void next()
  
/* "void next() 
      Falls die Liste nicht leer ist, es ein aktuelles Objekt gibt und die-
      ses nicht das letzte Objekt der Liste ist, wird das dem aktuellen 
      Objekt in der Liste folgende Objekt zum aktuellen Objekt, an-
      dernfalls gibt es nach Ausführung des Auftrags kein aktuelles 
      Objekt, d.h. hasAccess() liefert den Wert false."
 */
  {
    
if (hasAccess())
    {
      vorAktuell = vorAktuell.nächster;
    }
  }

  
public void toFirst()
  
/* "void toFirst() 
      Falls die Liste nicht leer ist, wird das erste Objekt der Liste aktu-
      elles Objekt. Ist die Liste leer, geschieht nichts."
 */ 
  {
    vorAktuell = vorAnfang; 
// kein Unterschied für leere Liste!
  }

  
public void toLast()
  
/* "void toLast() 
      Falls die Liste nicht leer ist, wird das letzte Objekt der Liste aktu-
      elles Objekt. Ist die Liste leer, geschieht nichts."
 */
  // Sinnvoller als toLast wäre behindLast gewesen, um dort mit insert nicht vor,
  
// sondern trotz hasAcceess=false wirklich hinter dem letzten Element einzufügen.
  
// Dann wäre append überflüssig.     
  {
    vorAktuell = vorEnde;  
// kein Unterschied für leere Liste!
  }

  
public Object getObject()
  
/* "Object getObject() 
      Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das 
      aktuelle Objekt zurückgegeben, andernfalls  
      (hasAccess()== false) gibt die Anfrage den Wert null zurück."
 */
  {
    
if (hasAccess())
    {
      
return (vorAktuell.nächster.inhalt);  
    }
    
else
    {
      
return (null);
    }
  }
  
  
public void setObject(Object pObject)
  
/* "void setObject(Object pObject) 
      Falls es ein aktuelles Objekt gibt (hasAccess() == true) und pOb-
      ject ungleich null ist, wird das aktuelle Objekt durch pObject er-
      setzt. Sonst bleibt die Liste unverändert."
 */
  // Der Name hört sich an, als wäre setObject ein Pendant zu getObject
  
// -- was so nicht stimmt. 
  
// Statt setObject wäre wohl der Name update oder substitute verständlicher
  
// und würde besser zu remove oder insert (oder auch append) passen.
  
// Wieso gibt es diese Methode überhaupt? -- Bei Stack und Queue gibt es auch
  
// keinen Befehl zum Ersetzen des aktuellen Elements! Zwar lässt sich 
  
// der Ersatz auch durch remove und insert bewirken; anschließend wäre aber
  
// dann - anders als bei setObject - das Folgeelement aktuell.   
  {
    
if (hasAccess() && pObject != null
    {
      vorAktuell.nächster.inhalt = pObject;     
// Inhalt überschreiben/ersetzen
    }
  }
  
  
public void append (Object pObject)
  
/* "void append(Object pObject) 
      Ein neues Objekt pObject wird am Ende der Liste eingefügt. Das 
      aktuelle Objekt bleibt unverändert. Wenn die Liste leer ist, wird 
      das Objekt pObject in die Liste eingefügt und es gibt weiterhin 
      kein aktuelles Objekt (hasAccess() == false). 
      Falls pObject gleich null ist, bleibt die Liste unverändert."
 */ 
  
// Wäre bei ordentlichem insert überflüssig
  {
    
if (pObject != null
    {
      Node neu = 
new Node (pObject, null);
      
if (!isEmpty())
      {       
        vorEnde.nächster.nächster = neu;     
// hinten dran
        vorEnde = vorEnde.nächster;          // Ende jetzt 1 später
      }
      
else
      {
        insert (pObject);
      }
    }
  }
  
  
public void insert (Object pObject)
  
/* "void insert(Object pObject) 
      Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird ein 
      neues Objekt vor dem aktuellen Objekt in die Liste eingefügt. 
      Das aktuelle Objekt bleibt unverändert. Falls die Liste leer ist 
      und es somit kein aktuelles Objekt gibt (hasAccess() == false), 
      wird pObject in die Liste eingefügt und es gibt weiterhin kein ak-
      tuelles Objekt. Falls es kein aktuelles Objekt gibt  
      (hasAccess() == false) und die Liste nicht leer ist oder pObject 
      gleich null ist, bleibt die Liste unverändert."
 */
  // Es erscheint wenig konsistent, dass insert bei der leeren Liste einmal 
  
// ein Element einfügt, beim wiederholten Aufruf aber nicht mehr, weil man
  
// erst mit toFirst oder toLast dafür sorgen muss, dass hasAccess true
  
// wird. Fügt man in eine neue, leere Liste mit insert (und toFirst oder toLast
  
// nach dem ersten Einfügen) nacheinander die Elemente a, b, c und d ein, 
  
// so stehen sie dann in der wenig erfreulichen Reihenfolge b-c-d-a 
  
// in der Liste!
  
// Hätte man die Chance genutzt, mit insert bei hasAccess=false am Ende 
  
// einzufügen (vgl. Anmerkung bei hasAccess), hätte man die vier Elemente
  
// a bis d mit insert automatisch als a-b-c-d in die vorher leere Liste
  
// gefügt.
  {
    
if (pObject != null)
    {
      Node neu = 
new Node (pObject, null);
      
if (isEmpty()) 
      {
        vorAnfang.nächster = neu;
        vorEnde = vorAnfang;
        vorAktuell = 
null;
      }
      
else
      {
        
if (hasAccess())
        {
          neu.nächster = vorAktuell.nächster;
          
          
if (vorEnde == vorAktuell)         // falls direkt vorm letzten Element
          {                                  // (letztes Element ist aktuell)
            vorEnde = neu;                   // eingefügt wird, muss vorEnde
          }                                  // korrigiert werden
                         
          vorAktuell.nächster = neu;
          vorAktuell = neu; 
        }
      }
    }
  }
   
  
public void remove()
  
/* "void remove() 
      Falls es ein aktuelles Objekt gibt (hasAccess() == true), wird das 
      aktuelle Objekt gelöscht und das Objekt hinter dem gelöschten 
      Objekt wird zum aktuellen Objekt. Wird das Objekt, das am Ende 
      der Liste steht, gelöscht, gibt es kein aktuelles Objekt mehr (has-
      Access() == false). Wenn die Liste leer ist oder es kein aktuel-
      les Objekt gibt (hasAccess() == false), bleibt die Liste unverän-
      dert."
 */
  {
    
if (!isEmpty() && hasAccess())
    {
      
if (vorAktuell.nächster == vorEnde)    // vorletzter raus?
      {                                                                        
        vorEnde = vorAktuell;                // geht mit 1 Schritt              
      };                                                                       
      vorAktuell.nächster = vorAktuell.nächster.nächster; 
        
// das bisherige akt. El. wird übersprungen und dadurch unzugänglich
      if (vorAktuell.nächster==null)         // letzter raus?                   
      {                                                                        
        vorEnde = vorAnfang;                 // dann vorEnde neu setzen         
        if (vorEnde.nächster != null)        // nämlich von Anfang an           
        {                                    // einmal durch die Liste          
          while (vorEnde.nächster.nächster != null)  // mit Aufwand             
          {                                  // entsprechend der                
            vorEnde = vorEnde.nächster;      // Elementzahl                     
          } // end of while                                                    
        } // end of if                                                         
      } // end of if                                                           
    }
  }

  
  
public void concat (List pList)
  
/* "void concat(List pList) 
      Die Liste pList wird an die Liste angehängt. Anschließend wird 
      pList eine leere Liste. Das aktuelle Objekt bleibt unverändert. 
      Falls pList null oder eine leere Liste ist, bleibt die Liste unverän-
      dert."
 */
  // Wieso hier, wenn nicht auch bei Queue und Stack?    
  
// Und was, wenn man eine Liste an sich selbst anhängen will? Hat das
  
// Ergebnis statt der doppelten Länge nachher die Länge 0, weil pList
  
// leer wird?
  {
    
if (pList != null && !pList.isEmpty())
    {
      vorEnde.nächster.nächster = pList.vorAnfang.nächster;
      pList = 
new List();  
    }
  }
  
  
  
// --- Zusatz-Methoden für die Listenkontrolle: ---
  
  
private String zeige (Node vorKnoten)
  {
    String ausgabe = 
"?";
    
if (vorKnoten == null)
    {
      ausgabe = 
"[vor~=null]";
    } 
    
else if (vorKnoten.nächster==null)
    {
      ausgabe = 
"[vor~.nächster=null]";
    } 
    
else
    {
      ausgabe = 
"\""+(String)(vorKnoten.nächster.inhalt)+"\"";
    }
    
return (ausgabe);
  }
  
  
public String kontrollAusgabe() // gibt zu Kontrollzwecken einen Text mit allen Listenelementen zurück.
  {
    String kontrolle;
    
if (isEmpty())
    {
       kontrolle = 
"Die Liste ist leer";
    } 
    
else 
    {
       kontrolle = 
"Liste: ";
       Node zeiger = vorAnfang.nächster;
       
int nr = 0;
       
while (zeiger != null)
       { 
         nr++;
         kontrolle = kontrolle + 
" "+nr+"=\""+zeiger.inhalt+"\"";
         zeiger = zeiger.nächster;
       } 
// end of while  
    }   
    
return (kontrolle+". (Anfang="+zeige(vorAnfang)+", Ende="+zeige(vorEnde)+", Aktuell="+zeige(vorAktuell)+")\n");     
  }
  
}


zum Seitenanfang / zum Seitenende

zurück zur Seite „Informatik mit Java, Teil e)"
oder zurück zur Seite „Informatik-Klausuren und Arbeitsblätter"


zum Anfang dieser Seite
Willkommen/Übersicht   -   Was ist neu?   -   Software   -   Mathematik   -   Physik   -   Informatik   -   Schule: Lessing-Gymnasium und -Berufskolleg   -   Fotovoltaik   -   & mehr   -   Kontakt: e-Mail,  News-Abo, Gästebuch, Impressum   -  Grußkarten, site map, Download und Suche

Diese Seite ist Teil des Webangebots http://www.r-krell.de. Sie können diese Seite per e-Mail weiter empfehlen (tell a friend).