Initial data commit

Task/Tree-traversal/Java/tree-traversal-1.java

@@ -0,0 +1,87 @@
+import java.util.*;
+
+public class TreeTraversal {
+
+        static class Node<T> {
+		T value;
+		Node<T> left;
+		Node<T> right;
+
+		Node(T value) {
+			this.value = value;
+		}
+
+		void visit() {
+			System.out.print(this.value + " ");
+		}
+	}
+
+	static enum ORDER {
+		PREORDER, INORDER, POSTORDER, LEVEL
+	}
+
+        static <T> void traverse(Node<T> node, ORDER order) {
+		if (node == null) {
+			return;
+		}
+		switch (order) {
+		case PREORDER:
+			node.visit();
+			traverse(node.left, order);
+			traverse(node.right, order);
+			break;
+		case INORDER:
+			traverse(node.left, order);
+			node.visit();
+			traverse(node.right, order);
+			break;
+		case POSTORDER:
+			traverse(node.left, order);
+			traverse(node.right, order);
+			node.visit();
+			break;
+		case LEVEL:
+			Queue<Node<T>> queue = new LinkedList<>();
+			queue.add(node);
+			while(!queue.isEmpty()){
+				Node<T> next = queue.remove();
+				next.visit();
+				if(next.left!=null)
+					queue.add(next.left);
+				if(next.right!=null)
+					queue.add(next.right);
+			}
+		}
+	}	
+
+	public static void main(String[] args) {
+
+		Node<Integer> one = new Node<Integer>(1);
+		Node<Integer> two = new Node<Integer>(2);
+		Node<Integer> three = new Node<Integer>(3);
+		Node<Integer> four = new Node<Integer>(4);
+		Node<Integer> five = new Node<Integer>(5);
+		Node<Integer> six = new Node<Integer>(6);
+		Node<Integer> seven = new Node<Integer>(7);
+		Node<Integer> eight = new Node<Integer>(8);
+		Node<Integer> nine = new Node<Integer>(9);
+		
+		one.left = two;
+		one.right = three;
+		two.left = four;
+		two.right = five;
+		three.left = six;
+		four.left = seven;
+		six.left = eight;
+		six.right = nine;
+
+		traverse(one, ORDER.PREORDER);
+		System.out.println();
+		traverse(one, ORDER.INORDER);
+		System.out.println();
+		traverse(one, ORDER.POSTORDER);
+		System.out.println();
+		traverse(one, ORDER.LEVEL);
+		
+	}
+}

Task/Tree-traversal/Java/tree-traversal-2.java

@@ -0,0 +1,126 @@
+import java.util.function.Consumer;
+import java.util.Queue;
+import java.util.LinkedList;
+
+class TreeTraversal {
+  static class EmptyNode {
+    void accept(Visitor aVisitor) {}
+
+    void accept(LevelOrder aVisitor, Queue<EmptyNode> data) {}
+  }
+
+  static class Node<T> extends EmptyNode {
+    T data;
+    EmptyNode left = new EmptyNode();
+    EmptyNode right = new EmptyNode();
+
+    Node(T data) {
+      this.data = data;
+    }
+
+    Node<T> left(Node<?> aNode) {
+      this.left = aNode;
+      return this;
+    }
+
+    Node<T> right(Node<?> aNode) {
+      this.right = aNode;
+      return this;
+    }
+
+    void accept(Visitor aVisitor) {
+      aVisitor.visit(this);
+    }
+
+    void accept(LevelOrder aVisitor, Queue<EmptyNode> data) {
+      aVisitor.visit(this, data);
+    }
+  }
+
+  static abstract class Visitor {
+    Consumer<Node<?>> action;
+
+    Visitor(Consumer<Node<?>> action) {
+      this.action = action;
+    }
+
+    abstract <T> void visit(Node<T> aNode);
+  }
+
+  static class PreOrder extends Visitor {
+    PreOrder(Consumer<Node<?>> action) {
+      super(action);
+    }
+
+    <T> void visit(Node<T> aNode) {
+      action.accept(aNode);
+      aNode.left.accept(this);
+      aNode.right.accept(this);
+    }
+  }
+
+  static class InOrder extends Visitor {
+    InOrder(Consumer<Node<?>> action) {
+      super(action);
+    }
+
+    <T> void visit(Node<T> aNode) {
+      aNode.left.accept(this);
+      action.accept(aNode);
+      aNode.right.accept(this);
+    }
+  }
+
+  static class PostOrder extends Visitor {
+    PostOrder(Consumer<Node<?>> action) {
+      super(action);
+    }
+
+    <T> void visit(Node<T> aNode) {
+      aNode.left.accept(this);
+      aNode.right.accept(this);
+      action.accept(aNode);
+    }
+  }
+
+  static class LevelOrder extends Visitor {
+    LevelOrder(Consumer<Node<?>> action) {
+      super(action);
+    }
+
+    <T> void visit(Node<T> aNode) {
+      Queue<EmptyNode> queue = new LinkedList<>();
+      queue.add(aNode);
+      do {
+        queue.remove().accept(this, queue);
+      } while (!queue.isEmpty());
+    }
+
+    <T> void visit(Node<T> aNode, Queue<EmptyNode> queue) {
+      action.accept(aNode);
+      queue.add(aNode.left);
+      queue.add(aNode.right);
+    }
+  }
+
+  public static void main(String[] args) {
+    Node<Integer> tree = new Node<Integer>(1)
+                          .left(new Node<Integer>(2)
+                            .left(new Node<Integer>(4)
+                              .left(new Node<Integer>(7)))
+                            .right(new Node<Integer>(5)))
+                          .right(new Node<Integer>(3)
+                            .left(new Node<Integer>(6)
+                              .left(new Node<Integer>(8))
+                              .right(new Node<Integer>(9))));
+    Consumer<Node<?>> print = aNode -> System.out.print(aNode.data + " ");
+    tree.accept(new PreOrder(print));
+    System.out.println();
+    tree.accept(new InOrder(print));
+    System.out.println();
+    tree.accept(new PostOrder(print));
+    System.out.println();
+    tree.accept(new LevelOrder(print));
+    System.out.println();
+  }
+}