added 05 exercise

05/src/main/java/ch/zhaw/ads/SortedBinaryTree.java

@@ -0,0 +1,130 @@
+package Praktikum_05_Code;
+
+import java.util.*;
+
+public class SortedBinaryTree<T extends Comparable<T>> implements Tree<T> {
+    protected TreeNode<T> root;
+
+    private TreeNode<T> insertAt(TreeNode<T> node, T x) {
+        if (node == null) {
+            return new TreeNode<T>(x);
+        } else {
+            if (x.compareTo(node.element) <= 0) {
+                node.left = insertAt(node.left, x);
+            } else {
+                node.right = insertAt(node.right, x);
+            }
+            return node;
+        }
+    }
+
+    public void add(T x) {
+        root = insertAt(root, x);
+    }
+
+    // find node to replace
+    private TreeNode<T> findRepAt(TreeNode<T> node, TreeNode<T> rep) {
+        if (node.right != null) {
+            node.right = findRepAt(node.right,rep);
+        } else {
+            rep.element = node.element;
+            node = node.left;
+        }
+        return node;
+    }
+
+    // remove node
+    private TreeNode<T> removeAt(TreeNode<T> node, T x,TreeNode<T> removed ) {
+        if (node == null) {
+            return null;
+        } else {
+            if (x.compareTo(node.element) == 0) {
+                // found
+                removed.element = node.element;
+                if (node.left == null) {
+                    node = node.right;
+                } else if (node.right == null) {
+                    node = node.left;
+                } else {
+                    node.left = findRepAt(node.left,node);
+                }
+            } else if (x.compareTo(node.element) < 0) {
+                // search left
+                node.left = removeAt(node.left, x, removed);
+            } else {
+                // search right
+                node.right = removeAt(node.right, x, removed);
+            }
+            return node;
+        }
+    }
+
+    public T remove(T x) {
+        TreeNode<T> removed = new TreeNode<T>(null);
+        root = removeAt(root, x, removed);
+        return removed.element;
+    }
+
+
+    public boolean isEmpty() {
+        return root == null;
+    }
+
+    public Traversal<T> traversal() {
+        // to be implemented
+    }
+
+    protected int calcHeight(TreeNode<T> node) {
+        // to be implemented
+    }
+
+
+    protected int calcSize(TreeNode p) {
+        // to be implemented
+    }
+
+    public int height() {
+        return calcHeight(root);
+    }
+
+    public int size() {
+        return calcSize(root);
+    }
+
+    public boolean balanced() {
+        throw new UnsupportedOperationException();
+    }
+
+    // only for testing and debugging purposes: show the structure of the tree
+    public String printTree() {
+        StringBuilder out = new StringBuilder();
+        if (root.right != null) {
+            printTree(root.right,out, true, "");
+        }
+        out.append(root.element+"\n");
+        if (root.left != null) {
+            printTree(root.left,out, false, "");
+        }
+        return out.toString();
+    }
+
+    private void printTree(TreeNode node, StringBuilder out, boolean isRight, String indent) {
+        if (node.right != null) {
+            printTree(node.right, out, true,
+                    indent + (isRight ? "        " : " |      "));
+        }
+        out.append(indent);
+        if (isRight) {
+            out.append(" /");
+        } else {
+            out.append(" \\");
+        }
+        out.append("----- ");
+        out.append(node.element+"\n");
+        if (node.left != null) {
+            printTree(node.left, out, false,
+                    indent + (isRight ? " |      " : "        "));
+        }
+    }
+
+}

05/src/main/java/ch/zhaw/ads/Traversal.java

@@ -0,0 +1,13 @@
+package Praktikum_05_Code;
+
+/* interface of Traversal ADT */
+public interface Traversal<T> {
+    /* traverse elements of tree in preorder */
+    public void preorder(Visitor<T> vistor);
+    /* traverse elements of tree in inorder */
+    public void inorder(Visitor<T> vistor);
+    /* traverse elements of tree in postorder */
+    public void postorder(Visitor<T> vistor);
+    /* traverse elements of tree in levelorder */
+    public void levelorder(Visitor<T> vistor);
+}

05/src/main/java/ch/zhaw/ads/Tree.java

@@ -0,0 +1,19 @@
+package Praktikum_05_Code;
+
+/* interface of Tree ADT */
+public interface Tree<T> {
+    /* add an element to the tree */
+    void add(T o);
+    /* remove an element; returns the element if found else return null */
+    T remove(T o);
+    /* test if tree is empty */
+    boolean isEmpty();
+    /* returns instance of class that implements traversal interface */
+    Traversal<T> traversal();
+    /* number of elements */
+    int size();
+    /* height of the tree */
+    int height();
+    /* is the tree balanced */
+    boolean balanced();
+}

05/src/main/java/ch/zhaw/ads/TreeNode.java

@@ -0,0 +1,19 @@
+package Praktikum_05_Code;
+
+class TreeNode<T extends Comparable<T>> {
+    T element;
+    TreeNode left, right;
+    int height;
+    int count;
+
+    TreeNode(T element){
+        this.element = element;
+        this.count = 1;
+        this.height = 1;
+    }
+    TreeNode(T element, TreeNode left, TreeNode right){
+        this(element); this.left = left; this.right = right;
+    }
+
+    T getValue(){return element;}
+}

05/src/main/java/ch/zhaw/ads/TreeTraversal.java

@@ -0,0 +1,23 @@
+package Praktikum_05_Code;
+
+public class TreeTraversal<T extends Comparable<T>> implements Traversal<T> {
+
+    private TreeNode<T> root;
+
+    public TreeTraversal(TreeNode<T> root) {
+        this.root = root;
+    }
+
+    public void inorder(Visitor<T> vis) {
+        // to be done
+    }
+
+    public void preorder(Visitor<T> vis) {
+        // to be done
+    }
+
+    public void postorder(Visitor<T> vis) {
+        // to be done
+    }
+
+}

05/src/main/java/ch/zhaw/ads/Visitor.java

@@ -0,0 +1,7 @@
+package Praktikum_05_Code;
+
+/* interface of visitor ADT */
+public interface Visitor<T> {
+    /* called for each element in the tree */
+    public void visit(T obj);
+}

05/src/test/java/ch/zhaw/ads/TreeTest.java

@@ -0,0 +1,63 @@
+package Praktikum_05_Code;
+
+import org.junit.Test;
+import org.junit.Before;
+import static org.junit.Assert.*;
+
+public class TreeTest {
+    Tree<String> tree;
+
+    @Before
+    public void setUp() throws Exception {
+        tree = new SortedBinaryTree<String>();
+        tree.add("B");
+        tree.add("A");
+        tree.add("C");
+        tree.add("D");
+    }
+
+    @Test
+    public void testInorder() {
+        Visitor<String> v = new MyVisitor<String>();
+        tree.traversal().inorder(v);
+        assertEquals("inorder", "ABCD", v.toString());
+    }
+
+    @Test
+    public void testPreorder() {
+        Visitor<String> v = new MyVisitor<String>();
+        tree.traversal().preorder(v);
+        assertEquals("preorder", "BACD", v.toString());
+    }
+
+    @Test
+    public void testPostorder() {
+        Visitor<String> v = new MyVisitor<String>();
+        tree.traversal().postorder(v);
+        assertEquals("postorder", "ADCB", v.toString());
+    }
+
+    @Test
+    public void testLevelorder() {
+        Visitor<String> v = new MyVisitor<String>();
+        tree.traversal().levelorder(v);
+        assertEquals("levelorder", "BACD", v.toString());
+    }
+}
+
+
+class MyVisitor<T> implements Visitor<T> {
+    StringBuilder output;
+
+    MyVisitor() {
+        output = new StringBuilder();
+    }
+
+    public void visit(T s) {
+        output.append(s);
+    }
+
+    public String toString() {
+        return output.toString();
+    }
+}