aa

AuD/.gitignore

@@ -0,0 +1,29 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

AuD/.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_20" default="true" project-jdk-name="20" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

AuD/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/untitled.iml" filepath="$PROJECT_DIR$/untitled.iml" />
+    </modules>
+  </component>
+</project>

AuD/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

AuD/AuD.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

AuD/src/UEB01/Main.java

@@ -0,0 +1,10 @@
+package UEB01;
+
+// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
+// then press Enter. You can now see whitespace characters in your code.
+public class Main {
+    public static void main(String[] args) {
+
+        
+    }
+}

AuD/src/UEB01/StopUhr.java

@@ -0,0 +1,21 @@
+package UEB01;
+
+public class StopUhr
+{
+	private long startTime, stopTime;
+
+	public void start()
+	{
+		startTime = System.nanoTime();
+	}
+
+	public void stop()
+	{
+		stopTime = System.nanoTime();
+	}
+
+	public long getDuration()
+	{
+		return stopTime - startTime;
+	}
+}

AuD/src/UEB01/Zeitmessung.java

@@ -0,0 +1,69 @@
+package UEB01;
+
+public class Zeitmessung
+{
+	static int tuWasCounter = 0;
+	private static double tuwas()
+	{
+		tuWasCounter++;
+		return Math.random();
+	}
+
+	// Linear
+	public static double func1(int n)
+	{
+		double summe = 0;
+
+		for (int a = 0; a < n; a++)
+			summe += tuwas();
+
+		return summe;
+	}
+
+	// Quadratisch
+	public static double func2(int n)
+	{
+		double summe = 0;
+
+		for (int a = 0; a < n; a++)
+			for(int b = 0; b < n; b++)
+				summe += tuwas();
+
+		return summe;
+	}
+
+	// log2(n)
+	public static double func6(int n)
+	{
+		double summe = 0;
+
+		while (n > 0)
+		{
+			summe += tuwas();
+			n /= 2;
+		}
+
+		return summe;
+	}
+
+	public static void main(String[] args)
+	{
+		StopUhr uhr = new StopUhr();
+		final int n = 100000;
+		tuWasCounter = 0;
+		uhr.start();
+		func1(n);
+		uhr.stop();
+		System.out.println("func1 "+"n="+n+" Zeit:"+uhr.getDuration()+" tuWasCounter:" + tuWasCounter);
+		tuWasCounter = 0;
+		uhr.start();
+		func2(n);
+		uhr.stop();
+		System.out.println("func2 "+"n="+n+" Zeit:"+uhr.getDuration()+" tuWasCounter:" + tuWasCounter);
+		tuWasCounter = 0;
+		uhr.start();
+		func6(n);
+		uhr.stop();
+		System.out.println("func6 "+"n="+n+" Zeit:"+uhr.getDuration()+" tuWasCounter:" + tuWasCounter);
+	}
+}

AuD/src/UEB03/Link.java

@@ -0,0 +1,20 @@
+package UEB03;
+
+public class Link<T>
+{
+	public T daten;
+	public Link<T> naechster;
+
+	public Link(T daten, Link<T> naechster)
+	{
+		assert(daten != null);
+
+		this.daten = daten;
+		this.naechster = naechster;
+	}
+
+	public String toString()
+	{
+		return daten.toString();
+	}
+}

AuD/src/UEB03/Liste.java

@@ -0,0 +1,189 @@
+package UEB03;
+
+import java.util.*;
+
+public class Liste<T>
+{
+	protected Link<T> anfang;
+	protected Link<T> ende;
+
+	public Liste()
+	{
+		// Leere Liste: alle Zeiger sind null (Standardwerte)
+	}
+
+	// Einfachster Fall und gleichzeitig Sonderfall:
+	// Element am Anfang einf<6E>gen
+	public void einfuegen(final T daten)
+	{
+		// Funktioniert immer
+		anfang = new Link<T>(daten, anfang);
+
+		// Bei einer leeren Liste muss auch ende gesetzt werden
+		if (ende == null)
+			ende = anfang;
+	}
+
+	// Einfachster Fall und gleichzeitig Sonderfall:
+	// Element am Anfang entfernen
+	public T entfernen()
+	{
+		T opfer = null;
+
+		// Clowns k<>nnten diese Methode bei leerer Liste aufrufen
+		if (!istLeer())
+		{
+			// Bei einer Liste mit nur noch einem Element muss
+			// auch ende gel<65>scht werden
+			if (anfang == ende)
+				ende = null;
+
+			opfer = anfang.daten;
+			anfang = anfang.naechster;
+		}
+
+		return opfer;
+	}
+
+	// Einfacher Fall: Anf<6E>gen am Ende der Liste
+	public void anfuegen(final T daten)
+	{
+		// Neuen Link anlegen
+		Link<T> neu = new Link<T>(daten, null);
+
+		// Wenn die Liste leer ist, m<>ssen anfang und ende gesetzt werden
+		if (istLeer())
+		{
+			// Neuen Link als anfang der Liste
+			anfang = ende = neu;
+		}
+		else
+		{
+			// Anf<6E>gen des Elements an das bisherige ende
+			ende = ende.naechster = neu;
+		}
+	}
+
+	// EINF<4E>GEN AN EINER BESTIMMTEN STELLE
+	// Der Programmcode ist so gestaltet, dass er fehlerhafte Eingaben
+	// (z.B. eine negative oder zu hohe Position) elegant verarbeitet
+	// ohne abzust<73>rzen.
+	public void einfuegen(final T daten, int position)
+	{
+		// Wenn die Liste leer oder die Position 0 ist, entspricht dies
+		// einem Einf<6E>gen am Anfang
+		if (istLeer() || (position <= 0))
+		{
+			einfuegen(daten);
+
+			return;
+		}
+
+		// VORG<52>NGER ZUR POSITION FINDEN
+		// Dessen Vorg<72>nger muss es geben: lediglich bei einer leeren
+		// Liste oder f<>r position==0 gibt es keinen. Genau diese F<>lle
+		// wurden aber oben bereits behandelt! Wird eine zu hohe position
+		// <20>bergeben, wird automatisch das letzte Element zum Vorg<72>nger.
+		Link<T> vorgaenger = anfang;
+
+		while ((--position > 0) && (vorgaenger.naechster != null))
+			vorgaenger = vorgaenger.naechster;
+
+		// Neues Element erzeugen
+		vorgaenger.naechster = new Link<T>(daten, vorgaenger.naechster);
+
+		// Beim Einf<6E>gen als letztes Element muss auch ende gesetzt werden
+		if (vorgaenger == ende)
+			ende = vorgaenger.naechster;
+	}
+
+	public T entfernen(int position)
+	{
+		// Wenn die Liste leer oder die position < 0 ist, wird kein Element
+		// entfernt
+		if (istLeer() || (position < 0))
+			return null;
+
+		// Wenn die position 0 ist, wird am Anfang der Liste gel<65>scht
+		if (position == 0)
+			return entfernen();
+
+		// VORG<52>NGER ZUR POSITION FINDEN
+		// Bei einer leeren Liste oder f<>r position==0 gibt es keinen Vorg<72>nger;
+		// genau diese F<>lle wurden oben bereits behandelt. Es gibt aber auch
+		// keinen Vorg<72>ner, wenn position zu gro<72> ist! In diesem Fall wird das
+		// letzte Element NICHT Vorg<72>nger, damit nur tats<74>chlich existierende
+		// Elemente aus der Liste entfernt werden.
+		Link<T> vorgaenger = anfang;
+
+		while ((--position > 0) && (vorgaenger != null))
+			vorgaenger = vorgaenger.naechster;
+
+		// Gibt es ein Element zum l<>schen?
+		if ((vorgaenger == null) || (vorgaenger.naechster == null))
+			return null;
+
+		final T opfer = vorgaenger.naechster.daten;
+
+		// Element l<>schen und ggf. ende anpassen beim L<>schen des letzten
+		// Listen-Elements
+		if ((vorgaenger.naechster = vorgaenger.naechster.naechster) == null)
+			ende = vorgaenger;
+
+		return opfer;
+	}
+
+	// Liefert die Position eines bestimmten Elements oder -1 zur<75>ck.
+	// Existiert ein Element mehrfach, wird die Position des ersten Vorkommens
+	// zur<75>ckgegeben.
+	public int suchen(final T daten)
+	{
+		// Liste leer?
+		if (istLeer())
+			return -1;
+
+		Link<T> zeiger = anfang;
+		int position = 0;
+
+		// Abfrage auf Gleichheit ist m<>glich mit equals (Operation von der Klasse Object)
+		while ((zeiger != null) && !zeiger.daten.equals(daten))
+		{
+			position++;
+			zeiger = zeiger.naechster;
+		}
+
+		return (zeiger == null) ? -1 : position;
+	}
+
+	public ListeIterator<T> iterator()
+	{
+		return new ListeIterator<T>(anfang, ende);
+	}
+
+	// Pr<50>fen, ob Liste leer ist
+	public boolean istLeer()
+	{
+		return anfang==null;
+	}
+
+	public void verketten(Liste<T> zweiteListe)
+	{
+		assert(zweiteListe != null);
+
+		ende.naechster = zweiteListe.anfang;
+		ende= zweiteListe.ende;
+		zweiteListe.anfang = null;
+		zweiteListe.ende = null;
+
+	}
+
+	public int entferneWerte(final T opfer)
+	{
+		int anzGeloeschte = 0;
+
+		// Diese Methode wird im Praktikum implementiert
+		// TODO
+
+		return anzGeloeschte;
+	}
+}

AuD/src/UEB03/ListeCanvas.java

@@ -0,0 +1,47 @@
+package UEB03;
+
+import java.awt.*;
+
+public class ListeCanvas extends Canvas
+{
+	private Liste eineListe;
+
+	public void zeichneNeu(Liste eineListe)
+	{
+		this.eineListe = eineListe;
+
+		repaint();
+	}
+
+	public void paint(Graphics g)
+	{
+		ListeIterator it = eineListe.iterator();
+		int x = 0;
+		int y = 30;
+		int position = 0;
+
+		while (it.hasNext())
+		{
+			g.setColor(new Color(0xE8, 0xE8, 0xFF));
+			g.fillRect(x+1, y+1, 30, 20);
+
+			g.setColor(Color.blue);
+			g.drawRect(x, y, 30, 20);
+
+			g.drawString(it.next().toString(), x + 1, y + 19);
+
+			if (it.hasNext())
+			{
+				g.setColor(Color.black);
+				g.drawLine(x + 30, y + 10, x + 45, y + 10);
+				g.drawLine(x + 45, y + 10, x + 40, y + 5);
+				g.drawLine(x + 45, y + 10, x + 40, y + 15);
+			}
+
+			g.setColor(Color.gray);
+			g.drawString("" + position++, x - 1, y + 35);
+
+			x = x + 45;
+		}
+	}
+}

AuD/src/UEB03/ListeGUI.java

@@ -0,0 +1,202 @@
+package UEB03;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.applet.*;
+import java.util.*;
+
+public class ListeGUI extends Frame
+{
+	//Attribute
+	protected Label wertFuehrungstext;
+	protected TextField wertTextfeld;
+	protected Label positionFuehrungstext;
+	protected TextField positionTextfeld;
+	protected Button einfuegenDruckknopf;
+	protected Button anhaengenDruckknopf;
+	protected Button entfernenDruckknopf;
+	protected Button alleEntfernenDruckknopf;
+	protected Button traversierenDruckknopf;
+	protected Button suchenDruckknopf;
+	protected Label ausgabeFuehrungstext;
+	protected TextArea ausgabeTextbereich;
+
+	protected Liste<Character> eineListe;
+	protected ListeCanvas eineZeichenflaeche; //Zeichenfl<66>che f<>r die Animation
+
+	//Operationen
+	public ListeGUI()
+	{
+		setTitle("Verkettete Liste");
+		setLayout(null);
+		setSize(492,315);
+		add(eineZeichenflaeche = new ListeCanvas());
+		eineZeichenflaeche.setBounds(32,32,430,80);
+		add(wertFuehrungstext= new Label());
+		wertFuehrungstext.setText("Wert:");
+		wertFuehrungstext.setBounds(30,112,58,23);
+		add(wertTextfeld = new TextField());
+		wertTextfeld.setBounds(90,112,45,23);
+		add(positionFuehrungstext= new Label());
+		positionFuehrungstext.setText("Position:");
+		positionFuehrungstext.setBounds(30,137,58,23);
+		add(positionTextfeld = new TextField());
+		positionTextfeld.setBounds(90,137,45,23);
+		add(einfuegenDruckknopf = new Button());
+		einfuegenDruckknopf.setLabel("Einf<EFBFBD>gen");
+		einfuegenDruckknopf.setBounds(30,170,100,23);
+		add(anhaengenDruckknopf = new Button());
+		anhaengenDruckknopf.setLabel("Anh<EFBFBD>ngen");
+		anhaengenDruckknopf.setBounds(140,170,100,23);
+		add(entfernenDruckknopf = new Button());
+		entfernenDruckknopf.setLabel("Entfernen");
+		entfernenDruckknopf.setBounds(250,170,100,23);
+		add(alleEntfernenDruckknopf = new Button());
+		alleEntfernenDruckknopf.setLabel("Alle entfernen");
+		alleEntfernenDruckknopf.setBounds(360,170,100,23);
+		add(traversierenDruckknopf = new Button());
+		traversierenDruckknopf.setLabel("Traversieren");
+		traversierenDruckknopf.setBounds(30,220,100,23);
+		add(suchenDruckknopf = new Button());
+		suchenDruckknopf.setLabel("Suchen");
+		suchenDruckknopf.setBounds(140,220,100,23);
+		add(ausgabeFuehrungstext= new Label());
+		ausgabeFuehrungstext.setText("Ausgabe:");
+		ausgabeFuehrungstext.setBounds(30,255,58,23);
+		add(ausgabeTextbereich = new TextArea("", 1, 1000, TextArea.SCROLLBARS_NONE));
+		ausgabeTextbereich.setBounds(90,255,370,23);
+		ausgabeTextbereich.setEnabled(false);
+
+		// Registrieren der Ereignisabh<62>rer
+		AktionsAbhoerer einAktionsAbhoerer = new AktionsAbhoerer();
+		einfuegenDruckknopf.addActionListener(einAktionsAbhoerer);
+		anhaengenDruckknopf.addActionListener(einAktionsAbhoerer);
+		entfernenDruckknopf.addActionListener(einAktionsAbhoerer);
+		alleEntfernenDruckknopf.addActionListener(einAktionsAbhoerer);
+		suchenDruckknopf.addActionListener(einAktionsAbhoerer);
+		traversierenDruckknopf.addActionListener(einAktionsAbhoerer);
+
+		// Test f<>r Verkettung zweier Listen
+		eineListe = new Liste<Character>();
+		eineListe.anfuegen(new Character('A'));
+		eineListe.anfuegen(new Character('B'));
+		Liste<Character> zweiteListe = new Liste<Character>();
+		zweiteListe.anfuegen(new Character('C'));
+		zweiteListe.anfuegen(new Character('D'));
+		eineListe.verketten(zweiteListe);
+
+		eineZeichenflaeche.zeichneNeu(eineListe);
+
+		addWindowListener(
+			new WindowAdapter()
+			{
+				public void windowClosing(WindowEvent e)
+				{
+					System.exit(0);
+				}
+			}
+		);
+	}
+
+	//Innere Klasse f<>r die Ereignisabh<62>rer
+	class AktionsAbhoerer implements ActionListener
+	{
+		private Character getCharacter()
+		{
+			final String s = wertTextfeld.getText();
+
+			return (s.length() > 0) ? s.charAt(0) : '?';
+		}
+
+		private int getPosition()
+		{
+			try
+			{
+				return Integer.valueOf(positionTextfeld.getText());
+			}
+			catch(NumberFormatException e)
+			{
+				ausgabeTextbereich.setText("Es wurde kein Position angegeben. Standardwert: 0 (Listenanfang)");
+			}
+
+			return 0;
+		}
+
+		private void finish()
+		{
+			wertTextfeld.setText("");
+			positionTextfeld.setText("");
+
+			eineZeichenflaeche.zeichneNeu(eineListe);
+		}
+
+		private void finish(final String ausgabe)
+		{
+			ausgabeTextbereich.setText(ausgabe);
+
+			finish();
+		}
+
+		public void actionPerformed(ActionEvent event)
+		{
+			Object o = event.getSource();
+			ausgabeTextbereich.setText("");
+
+			if (o == einfuegenDruckknopf)
+			{
+				eineListe.einfuegen(getCharacter(), getPosition());
+				finish();
+
+				return;
+			}
+
+			if (o == anhaengenDruckknopf)
+			{
+				eineListe.anfuegen(getCharacter());
+				finish();
+
+				return;
+			}
+
+			if (o == entfernenDruckknopf)
+			{
+				if (eineListe.entfernen(getPosition()) == null)
+					ausgabeTextbereich.setText("Es wurde kein Opfer gefunden!");
+
+				finish();
+
+				return;
+			}
+
+			if (o == suchenDruckknopf)
+			{
+				final int position = eineListe.suchen(getCharacter());
+				finish(position == -1 ? "Der Wert wurde nicht gefunden." : "Der gesuchte Wert wird zum ersten Mal an Position " + position + " gefunden.");
+
+				return;
+			}
+
+			if (o == alleEntfernenDruckknopf)
+			{
+				finish(eineListe.entferneWerte(getCharacter()) + " Elemente wurden entfernt.");
+
+				return;
+			}
+
+			if (o == traversierenDruckknopf)
+			{
+				String ausgabe = "";
+
+				ListeIterator<Character> e = eineListe.iterator();
+				while (e.hasNext())
+					ausgabe += e.next() + " ";
+
+				finish(ausgabe);
+
+				return;
+			}
+
+			finish();
+		}
+	}
+}

AuD/src/UEB03/ListeIterator.java

@@ -0,0 +1,33 @@
+package UEB03;
+
+import java.util.*;
+
+public class ListeIterator<T> implements Iterator
+{
+	private Link<T> zeiger;
+	private Link<T> ende;
+
+	ListeIterator(Link<T> start, Link<T> ende)
+	{
+		zeiger = start;
+		this.ende = ende;
+	}
+
+	public boolean hasNext()
+	{
+		return zeiger != null;
+	}
+
+	public T next()
+	{
+		final T daten = zeiger.daten;
+		zeiger = zeiger.naechster;
+
+		return daten;
+	}
+
+	public void remove()
+	{
+		throw new UnsupportedOperationException();
+	}
+}

AuD/src/UEB03/ListeTest.java

@@ -0,0 +1,9 @@
+package UEB03;
+
+public class ListeTest
+{
+	public static void main(String[] args)
+	{
+		new ListeGUI().setVisible(true);
+	}
+}

AuD/src/UEB03/Main.java

@@ -0,0 +1,10 @@
+package UEB03;
+
+public class Main {
+    public static void main(String[] args) {
+        Link<String> ende = new Link<String>("Letzter", null);
+        Link<String> mittleresElement = new Link<String>("Test", ende);
+        Link<String> anfang= new Link<String>("TErster", mittleresElement);
+
+    }
+}