Subtrees hinzugefügt

Quellcodes/Alg_DS_Stack/.gitignore

@@ -0,0 +1,7 @@
+**/*.sh
+**/*.class
+**/*.ctxt
+repo.adoc
+repo_subtree.adoc
+/alt
+/hide

Quellcodes/Alg_DS_Stack/01_stack_roh/ArrayStack.java

@@ -0,0 +1,48 @@
+
+/**
+ * Ein Stack basierend auf einem Array
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class ArrayStack<T> extends Stack<T>
+{
+    /**
+     * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist)
+     * @return Das oberste Element
+     */
+    public T top()
+    {
+        //# TODO: Hier ist etwas zu tun!
+        return null;
+    }
+    
+    /**
+     * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück
+     * @return Das bisherige oberste Element
+     */
+    public T pop()
+    {
+        //# TODO: Hier ist etwas zu tun!
+        return null;
+    }
+    
+    /**
+     * Legt ein neues Element auf den Stack
+     * @param x Das neue Element
+     */
+    public void push(T wert)
+    {
+        //# TODO: Hier ist etwas zu tun!
+    }
+    
+    /**
+     * Gibt zurück, ob der Stack leer ist
+     * @return true, wenn der Stack leer ist; false sonst
+     */
+    public boolean isEmpty()
+    {
+        //# TODO: Hier ist etwas zu tun!
+        return false;
+    }
+}

Quellcodes/Alg_DS_Stack/01_stack_roh/ArrayStackTester.java

@@ -0,0 +1,16 @@
+import org.junit.Before;
+
+/**
+ * Testklasse für den ArrayStack
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class ArrayStackTester extends StackTester
+{
+    @Before
+    public void setUp()
+    {
+        theStack = new ArrayStack<Integer>();
+    }
+}

Quellcodes/Alg_DS_Stack/01_stack_roh/LinkedStack.java

@@ -0,0 +1,48 @@
+
+/**
+ * Ein Stack basierend auf einer verketteten Liste
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class LinkedStack<T> extends Stack<T>
+{
+    /**
+     * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist)
+     * @return Das oberste Element
+     */
+    public T top()
+    {
+        //# TODO: Hier ist etwas zu tun!
+        return null;
+    }
+    
+    /**
+     * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück
+     * @return Das bisherige oberste Element
+     */
+    public T pop()
+    {
+        //# TODO: Hier ist etwas zu tun!
+        return null;
+    }
+    
+    /**
+     * Legt ein neues Element auf den Stack
+     * @param x Das neue Element
+     */
+    public void push(T wert)
+    {
+        //# TODO: Hier ist etwas zu tun!
+    }
+    
+    /**
+     * Gibt zurück, ob der Stack leer ist
+     * @return true, wenn der Stack leer ist; false sonst
+     */
+    public boolean isEmpty()
+    {
+        //# TODO: Hier ist etwas zu tun!
+        return false;
+    }
+}

Quellcodes/Alg_DS_Stack/01_stack_roh/LinkedStackTester.java

@@ -0,0 +1,16 @@
+import org.junit.Before;
+
+/**
+ * Testklasse für den LinkedStack
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class LinkedStackTester extends StackTester
+{
+    @Before
+    public void setUp()
+    {
+        theStack = new LinkedStack<Integer>();
+    }
+}

Quellcodes/Alg_DS_Stack/01_stack_roh/README.TXT

@@ -0,0 +1,5 @@
+PROJEKTBEZEICHNUNG: Stack
+PROJEKTZWECK: Zwei Implementationen des ADTs Stack
+VERSION oder DATUM: Oktober 2020
+WIE IST DAS PROJEKT ZU STARTEN: Implementieren Sie den ArrayStack oder den LinkedStack. Führen Sie dann bei den entsprechenden Tester-Klassen "Alles testen" aus.
+AUTOR(EN): Rainer Helfrich, ZPG Informatik

Quellcodes/Alg_DS_Stack/01_stack_roh/Stack.java

@@ -0,0 +1,32 @@
+/**
+ * Abstrakte Basisklasse für Stacks
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public abstract class Stack<T>
+{
+    /**
+     * Gibt zurück, ob der Stack leer ist
+     * @return true, wenn der Stack leer ist; false sonst
+     */
+    public abstract boolean isEmpty();
+    
+    /**
+     * Legt ein neues Element auf den Stack
+     * @param x Das neue Element
+     */
+    public abstract void push(T x);
+    
+    /**
+     * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück
+     * @return Das bisherige oberste Element
+     */
+    public abstract T pop();
+    
+    /**
+     * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist)
+     * @return Das oberste Element
+     */
+    public abstract T top();
+}

Quellcodes/Alg_DS_Stack/01_stack_roh/package.bluej

@@ -0,0 +1,76 @@
+#BlueJ package file
+dependency1.from=StackTester
+dependency1.to=Stack
+dependency1.type=UsesDependency
+dependency2.from=LinkedStackTester
+dependency2.to=LinkedStack
+dependency2.type=UsesDependency
+dependency3.from=ArrayStackTester
+dependency3.to=ArrayStack
+dependency3.type=UsesDependency
+editor.fx.0.height=739
+editor.fx.0.width=816
+editor.fx.0.x=59
+editor.fx.0.y=61
+objectbench.height=109
+objectbench.width=861
+package.divider.horizontal=0.6
+package.divider.vertical=0.768
+package.editor.height=377
+package.editor.width=750
+package.editor.x=26
+package.editor.y=198
+package.frame.height=600
+package.frame.width=901
+package.numDependencies=3
+package.numTargets=6
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=StackTester
+target1.showInterface=false
+target1.type=AbstractTarget
+target1.width=100
+target1.x=170
+target1.y=190
+target2.height=50
+target2.name=LinkedStack
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=130
+target2.x=330
+target2.y=140
+target3.height=50
+target3.name=LinkedStackTester
+target3.showInterface=false
+target3.type=UnitTestTargetJunit4
+target3.width=140
+target3.x=230
+target3.y=290
+target4.height=50
+target4.name=ArrayStackTester
+target4.showInterface=false
+target4.type=UnitTestTargetJunit4
+target4.width=130
+target4.x=40
+target4.y=290
+target5.height=50
+target5.name=ArrayStack
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=120
+target5.x=20
+target5.y=140
+target6.height=50
+target6.name=Stack
+target6.showInterface=false
+target6.type=AbstractTarget
+target6.width=80
+target6.x=180
+target6.y=60

Quellcodes/Alg_DS_Stack/02_stack_loes/ArrayStack.java

@@ -0,0 +1,101 @@
+
+/**
+ * Ein Stack basierend auf einem Array
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class ArrayStack<T> extends Stack<T>
+{
+    /**
+     * Enthält die Nutzdaten
+     */
+    private Object[] daten;
+    /**
+     * Die Zahl gibt an, wie viele Elemente auf dem Stack liegen und damit auch,
+     * wie viele Werte im Datenarray gültig sind.
+     */
+    private int anzahl;
+
+    /**
+     * Erzeugt einen neuen leeren Stack
+     */
+    public ArrayStack()
+    {
+        daten = new Object[10];
+        anzahl = 0;
+    }
+    
+    /**
+     * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist)
+     * @return Das oberste Element
+     */
+    public T top()
+    {
+        if (!isEmpty())
+        {
+            return (T)daten[anzahl-1];
+        }
+        return null;
+    }
+    
+    /**
+     * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück
+     * @return Das bisherige oberste Element
+     */
+    public T pop()
+    {
+        if (!isEmpty())
+        {
+            anzahl--;
+            return (T)daten[anzahl];
+        }
+        return null;
+    }
+    
+    /**
+     * Legt ein neues Element auf den Stack
+     * @param x Das neue Element
+     */
+    public void push(T wert)
+    {
+        if (anzahl == daten.length)
+        {
+            Object[] tmp = new Object[2*daten.length];
+            System.arraycopy(daten, 0, tmp, 0, daten.length);
+            daten = tmp;
+        }
+        daten[anzahl] = wert;
+        anzahl++;
+    }
+    
+    /**
+     * Gibt zurück, ob der Stack leer ist
+     * @return true, wenn der Stack leer ist; false sonst
+     */
+    public boolean isEmpty()
+    {
+        return anzahl == 0;
+    }
+    
+    /**
+     * Gibt den Stack in String-Form aus.
+     * @return Die String-Repräsentation des Stacks
+     */
+    @Override
+    public String toString()
+    {
+        StringBuilder b = new StringBuilder();
+        b.append("[ ");
+        for (int i = 0; i < anzahl; i++)
+        {
+            if (i > 0)
+            {
+                b.append(", ");
+            }
+            b.append(daten[i]);
+        }
+        b.append(" <");
+        return b.toString();
+    }
+}

Quellcodes/Alg_DS_Stack/02_stack_loes/ArrayStackTester.java

@@ -0,0 +1,16 @@
+import org.junit.Before;
+
+/**
+ * Testklasse für den ArrayStack
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class ArrayStackTester extends StackTester
+{
+    @Before
+    public void setUp()
+    {
+        theStack = new ArrayStack<Integer>();
+    }
+}

Quellcodes/Alg_DS_Stack/02_stack_loes/CantorStack.java

@@ -0,0 +1,121 @@
+import java.math.BigInteger;
+
+/**
+ * Ein Stack basierend auf der Cantorschen Paarungsfunktion
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class CantorStack extends Stack<Integer>
+{
+    /**
+     * Die Zahl, die den Stack repräsentiert
+     */
+    private BigInteger stack;
+    
+    /**
+     * Erzeugt einen neuen leeren Stack
+     */
+    public CantorStack()
+    {
+        stack = BigInteger.TWO;
+    }
+    
+    /**
+     * Gibt zurück, ob der Stack leer ist
+     * @return true, wenn der Stack leer ist; false sonst
+     */
+    public boolean isEmpty()
+    {
+        return stack.equals(BigInteger.TWO);
+    }
+    
+    /**
+     * Legt ein neues Element auf den Stack
+     * @param x Das neue Element
+     */
+    public void push(Integer wert)
+    {
+        BigInteger y = BigInteger.valueOf(wert);
+        BigInteger x = stack;
+        BigInteger t1 = x.add(y);
+        BigInteger t2 = t1.add(BigInteger.ONE);
+        BigInteger t3 = t1.multiply(t2).shiftRight(1);
+        System.out.print("Push: (" + stack + " x " + wert + ") -> ");
+        stack = y.add(t3);
+        System.out.println(stack);
+    }
+    
+    /**
+     * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist)
+     * @return Das oberste Element
+     */
+    public Integer top()
+    {
+        if (isEmpty())
+        {
+            return null;
+        }
+        BigInteger top = topInt();
+        System.out.println("Top: " + top);
+        return top.intValue();
+    }
+    
+    private BigInteger topInt()
+    {
+        return stack.subtract(f(q(stack)));
+    }
+    
+    /**
+     * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück
+     * @return Das bisherige oberste Element
+     */
+    public Integer pop()
+    {
+        if (isEmpty())
+        {
+            return null;
+        }
+        BigInteger top = topInt();
+        System.out.print("Pop: " + stack + " -> (");
+        stack = q(stack).subtract(top);
+        System.out.println(stack + "," + top +")");
+        return top.intValue();
+    }
+    
+    private BigInteger f(BigInteger w)
+    {
+        return w.multiply(w.add(BigInteger.ONE)).shiftRight(1);
+    }
+    
+    private BigInteger q(BigInteger z)
+    {
+        return z.shiftLeft(3).add(BigInteger.ONE).sqrt().subtract(BigInteger.ONE).shiftRight(1);
+    }
+    
+    /**
+     * Gibt den Stack in String-Form aus.
+     * @return Die String-Repräsentation des Stacks
+     */
+    @Override
+    public String toString()
+    {
+        String ergebnis = " <";
+        CantorStack s = new CantorStack();
+        while(!this.isEmpty())
+        {
+            Integer top = pop();
+            s.push(top);
+            ergebnis = top + ergebnis;
+            if (!isEmpty())
+            {
+                ergebnis = ", " + ergebnis;
+            }
+        }
+        while(!s.isEmpty())
+        {
+            push(s.pop());
+        }
+        return "[ " + ergebnis;
+    }
+}

Quellcodes/Alg_DS_Stack/02_stack_loes/CantorStackTester.java

@@ -0,0 +1,16 @@
+import org.junit.Before;
+
+/**
+ * Testklasse für den LinkedStack
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class CantorStackTester extends StackTester
+{
+    @Before
+    public void setUp()
+    {
+        theStack = new CantorStack();
+    }
+}

Quellcodes/Alg_DS_Stack/02_stack_loes/LinkedStack.java

@@ -0,0 +1,115 @@
+
+/**
+ * Ein Stack basierend auf einer verketteten Liste
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class LinkedStack<T> extends Stack<T>
+{
+    /**
+     * Das oberste Element des Stacks
+     */
+    private Listenknoten<T> topNode;
+
+    /**
+     * Erzeugt einen neuen leeren Stack
+     */
+    public LinkedStack()
+    {
+        topNode = null;
+    }
+
+    /**
+     * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist)
+     * @return Das oberste Element
+     */
+    public T top()
+    {
+        if (!isEmpty())
+        {
+            return topNode.daten;
+        }
+        return null;
+    }
+
+    /**
+     * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück
+     * @return Das bisherige oberste Element
+     */
+    public T pop()
+    {
+        T top = null;
+        if (!isEmpty())
+        {
+            top = topNode.daten;
+            topNode = topNode.nachfolger;
+        }
+        return top;
+    }
+
+    /**
+     * Legt ein neues Element auf den Stack
+     * @param x Das neue Element
+     */
+    public void push(T wert)
+    {
+        topNode = new Listenknoten<T>(wert, topNode);
+    }
+
+    /**
+     * Gibt zurück, ob der Stack leer ist
+     * @return true, wenn der Stack leer ist; false sonst
+     */
+    public boolean isEmpty()
+    {
+        return topNode == null;
+    }
+
+    /**
+     * Ein Listenknoten, wie er bei den verketteten Listen verwendet wurde.
+     * Diesmal allerdings als innere Klasse
+     */
+    private class Listenknoten<T>
+    {
+        /**
+         * Der Datenwert des Listenknotens
+         */ 
+        public T daten;
+        /**
+         * Der Nachfolger des Listenknotens
+         */
+        public Listenknoten<T> nachfolger;
+
+        /**
+         * Erzeugt einen neuen Listenknoten
+         * 
+         * @param daten Der Datenwert des Knotens
+         * @param nachfolger Der Nachfolger des Knotens
+         */ 
+        public Listenknoten(T daten, Listenknoten<T> nachfolger)
+        {
+            this.daten = daten;
+            this.nachfolger = nachfolger;
+        }
+    }
+    
+    /**
+     * Gibt den Stack in String-Form aus.
+     * @return Die String-Repräsentation des Stacks
+     */
+    @Override
+    public String toString()
+    {
+        String ergebnis = " <";
+        Listenknoten k = this.topNode;
+        while(k != null)
+        {
+            ergebnis = k.daten + ergebnis;
+            if (k.nachfolger != null)
+                ergebnis = ", " + ergebnis;
+            k = k.nachfolger;
+        }
+        return "[ " + ergebnis;
+    }
+}

Quellcodes/Alg_DS_Stack/02_stack_loes/LinkedStackTester.java

@@ -0,0 +1,16 @@
+import org.junit.Before;
+
+/**
+ * Testklasse für den LinkedStack
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public class LinkedStackTester extends StackTester
+{
+    @Before
+    public void setUp()
+    {
+        theStack = new LinkedStack<Integer>();
+    }
+}

Quellcodes/Alg_DS_Stack/02_stack_loes/README.TXT

@@ -0,0 +1,5 @@
+PROJEKTBEZEICHNUNG: Stack
+PROJEKTZWECK: Zwei Implementationen des ADTs Stack
+VERSION oder DATUM: Oktober 2020
+WIE IST DAS PROJEKT ZU STARTEN: Implementieren Sie den ArrayStack oder den LinkedStack. Führen Sie dann bei den entsprechenden Tester-Klassen "Alles testen" aus.
+AUTOR(EN): Rainer Helfrich, ZPG Informatik

Quellcodes/Alg_DS_Stack/02_stack_loes/Stack.java

@@ -0,0 +1,32 @@
+/**
+ * Abstrakte Basisklasse für Stacks
+ * 
+ * @author Rainer Helfrich
+ * @version Oktober 2020
+ */
+public abstract class Stack<T>
+{
+    /**
+     * Gibt zurück, ob der Stack leer ist
+     * @return true, wenn der Stack leer ist; false sonst
+     */
+    public abstract boolean isEmpty();
+    
+    /**
+     * Legt ein neues Element auf den Stack
+     * @param x Das neue Element
+     */
+    public abstract void push(T x);
+    
+    /**
+     * Entfernt das oberste Element vom Stack (falls der Stack nicht leer ist) und gibt es zurück
+     * @return Das bisherige oberste Element
+     */
+    public abstract T pop();
+    
+    /**
+     * Gibt das oberste Element des Stacks zurück (falls der Stack nicht leer ist)
+     * @return Das oberste Element
+     */
+    public abstract T top();
+}

Quellcodes/Alg_DS_Stack/02_stack_loes/package.bluej

@@ -0,0 +1,93 @@
+#BlueJ package file
+dependency1.from=StackTester
+dependency1.to=Stack
+dependency1.type=UsesDependency
+dependency2.from=CantorStackTester
+dependency2.to=CantorStack
+dependency2.type=UsesDependency
+dependency3.from=LinkedStackTester
+dependency3.to=LinkedStack
+dependency3.type=UsesDependency
+dependency4.from=ArrayStackTester
+dependency4.to=ArrayStack
+dependency4.type=UsesDependency
+editor.fx.0.height=709
+editor.fx.0.width=1184
+editor.fx.0.x=14
+editor.fx.0.y=113
+objectbench.height=121
+objectbench.width=840
+package.divider.horizontal=0.6
+package.divider.vertical=0.7668488160291439
+package.editor.height=414
+package.editor.width=729
+package.editor.x=914
+package.editor.y=77
+package.frame.height=649
+package.frame.width=880
+package.numDependencies=4
+package.numTargets=8
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=StackTester
+target1.showInterface=false
+target1.type=AbstractTarget
+target1.width=100
+target1.x=170
+target1.y=190
+target2.height=50
+target2.name=CantorStack
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=100
+target2.x=420
+target2.y=220
+target3.height=50
+target3.name=CantorStackTester
+target3.showInterface=false
+target3.type=UnitTestTargetJunit4
+target3.width=140
+target3.x=400
+target3.y=290
+target4.height=50
+target4.name=LinkedStack
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=130
+target4.x=400
+target4.y=130
+target5.height=50
+target5.name=LinkedStackTester
+target5.showInterface=false
+target5.type=UnitTestTargetJunit4
+target5.width=140
+target5.x=230
+target5.y=290
+target6.height=50
+target6.name=ArrayStackTester
+target6.showInterface=false
+target6.type=UnitTestTargetJunit4
+target6.width=130
+target6.x=40
+target6.y=290
+target7.height=50
+target7.name=ArrayStack
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=120
+target7.x=0
+target7.y=140
+target8.height=50
+target8.name=Stack
+target8.showInterface=false
+target8.type=AbstractTarget
+target8.width=80
+target8.x=180
+target8.y=80

Quellcodes/Alg_DS_Stack/readme.adoc

@@ -0,0 +1,11 @@
+= Material :
+
+|===
+|Zuordnung| 
+|Klassenstufe| 
+|Bildungsplanbezug | 
+|Werkzeug| 
+|Autoren| 
+|===
+
+== Inhalt