Implementation of Tree Traversal in java (#149)

* Added java examples for Tree Traversal

* Added java in mk file

* Combined example and explanation code in one file

* Updated markdown file

* Added method overloading

* Removed useless spaces

* Updated Markdown file

* Updated code for coding conventions

* Moved temp variable in bfsQueue()

* Update tree_traversal.md

Author: xam4lor

chapters/tree_traversal/code/java/MainClass.java

@@ -0,0 +1,31 @@
+//submitted by xam4lor
+public class MainClass {
+    public static void main(String[] args) {
+        System.out.println("Creating Tree");
+        Tree tree = new Tree(3, 3);
+
+        System.out.println("Using recursive DFS :");
+        tree.dfsRecursive();
+
+        System.out.println("Using stack-based DFS :");
+        tree.dfsStack();
+
+        System.out.println("Using queue-based BFS :");
+        tree.bfsQueue();
+
+        System.out.println("Using post-order recursive DFS :");
+        tree.dfsRecursivePostOrder();
+
+
+        // Uncommenting the following 2 lines will result in an exception thrown because at least one Node of the Tree has more than 2 children and therefor a DFSRecursiveInorderBinary doesn't work.
+        System.out.println("Using in-order binary recursive DFS : (fail)");
+        tree.dfsRecursiveInOrderBinary();
+
+        tree = new Tree(3, 2);
+        System.out.println("Using in-order binary recursive DFS : (suceed)");
+        tree.dfsRecursiveInOrderBinary();
+
+
+        System.out.println("");
+    }
+}

chapters/tree_traversal/code/java/Tree.java

@@ -0,0 +1,127 @@
+// submitted by xam4lor
+import java.util.ArrayList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+import java.util.Stack;
+
+public class Tree {
+    public Node root;
+
+    public Tree(int rowCount, int childrenCount) {
+        // this.root is the root node of the Tree
+        this.root = new Node(1);
+        this.createAllChildren(this.root, rowCount, childrenCount);
+    }
+
+
+    public void dfsRecursive() {
+        this.dfsRecursive(this.root);
+    }
+
+    private void dfsRecursive(Node node) {
+        System.out.println(node.id);
+
+        for (Node n : node.children) {
+            dfsRecursive(n);
+        }
+    }
+
+
+    public void dfsRecursivePostOrder() {
+        this.dfsRecursivePostOrder(this.root);
+    }
+
+    private void dfsRecursivePostOrder(Node node) {
+        for (Node n : node.children) {
+            dfsRecursivePostOrder(n);
+        }
+
+        // Here we are doing something ...
+        System.out.println(node.id);
+    }
+
+
+    public void dfsRecursiveInOrderBinary() {
+        dfsRecursiveInOrderBinary(this.root);
+    }
+
+    // This assumes only 2 children
+    private void dfsRecursiveInOrderBinary(Node node) {
+        if (node.children.size() > 2) {
+            System.err.println("Not a binary tree at dfsRecursiveInOrderBinary()!");
+            return;
+        }
+
+        if (node.children.size() > 1) {
+            dfsRecursiveInOrderBinary(node.children.get(0));
+            System.out.println(node.id);
+            dfsRecursiveInOrderBinary(node.children.get(1));
+        } else {
+            System.out.println(node.id);
+        }
+    }
+
+
+    public void dfsStack() {
+        Stack<Node> stack = new Stack<Node>();
+        stack.push(this.root);
+
+        Node tmp;
+
+        while (stack.size() != 0) {
+            System.out.println(stack.peek().id);
+            tmp = stack.pop();
+
+            for (Node c : tmp.children) {
+                stack.push(c);
+            }
+        }
+    }
+
+    public void bfsQueue() {
+        Queue<Node> queue = new PriorityQueue<Node>();
+        queue.add(this.root);
+
+        while (queue.size() != 0) {
+            System.out.println(queue.peek().id);
+            Node temp = queue.poll(); // return null if the queue is empty
+
+            if (temp != null) {
+                for (Node c : temp.children) {
+                    queue.add(c);
+                }
+            }
+        }
+    }
+
+
+    private void createAllChildren(Node node, int rowCount, int childrenCount) {
+        if (rowCount <= 1) {
+           return; 
+        }
+
+        for (int i = 0; i < childrenCount; i++) {
+            node.children.add(new Node(node.id * 10 + i + 1));
+            createAllChildren(node.children.get(i), rowCount - 1, childrenCount);
+        }
+    }
+
+
+    private class Node implements Comparable<Node> {
+        public ArrayList<Node> children;
+        public int id;
+
+        public Node(int id) {
+            this.children = new ArrayList<Node>();
+            this.id = id;
+        }
+
+        @Override
+        public int compareTo(Node other) {
+            // Need to implement Comparable<Node> and override this
+            // method because of the method BFSQueue() which uses Queues
+            // and must know how to check if two nodes are the same or not
+            return Integer.compare(this.id, other.id);
+        }
+    }
+}

chapters/tree_traversal/tree_traversal.md

@@ -11,6 +11,8 @@ Trees are naturally recursive data structures, and because of this, we cannot ac
 [import:9-15, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:7-11, lang:"c_cpp"](code/c/tree_traversal.c)
+{% sample lang="java" %}
+[import:110-126, lang:"java"](code/java/Tree.java)
 {% sample lang="js" %}
 This has not been implemented in your chosen language, so here is the Julia code
 [import:3-7, lang:"julia"](code/julia/Tree.jl)
@@ -36,6 +38,8 @@ Because of this, the most straightforward way to traverse the tree might be recu
 [import:25-36, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:37-45, lang:"c_cpp"](code/c/tree_traversal.c)
+{% sample lang="java" %}
+[import:21-27, lang:"java"](code/java/Tree.java)
 {% sample lang="js" %}
 [import:12-15, lang:"javascript"](code/javascript/tree.js)
 {% sample lang="py" %}
@@ -70,6 +74,8 @@ This has not been implemented in your chosen language, so here is the Julia code
 [import:38-49, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:47-53, lang:"c_cpp"](code/c/tree_traversal.c)
+{% sample lang="java" %}
+[import:34-41, lang:"java"](code/java/Tree.java)
 {% sample lang="js" %}
 [import:17-20, lang:"javascript"](code/javascript/tree.js)
 {% sample lang="py" %}
@@ -101,6 +107,8 @@ This has not been implemented in your chosen language, so here is the Julia code
 [import:51-70, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:55-73, lang:"c_cpp"](code/c/tree_traversal.c)
+{% sample lang="java" %}
+[import:48-62, lang:"java"](code/java/Tree.java)
 {% sample lang="js" %}
 [import:22-34, lang:"javascript"](code/javascript/tree.js)
 {% sample lang="py" %}
@@ -141,6 +149,8 @@ In code, it looks like this:
 [import:72-86, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:75-93, lang:"c_cpp"](code/c/tree_traversal.c)
+{% sample lang="java" %}
+[import:65-79, lang:"java"](code/java/Tree.java)
 {% sample lang="js" %}
 [import:36-43, lang:"javascript"](code/javascript/tree.js)
 {% sample lang="py" %}
@@ -172,6 +182,8 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
 [import:88-102, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:95-113, lang:"c_cpp"](code/c/tree_traversal.c)
+{% sample lang="java" %}
+[import:81-95, lang:"java"](code/java/Tree.java)
 {% sample lang="js" %}
 [import:45-52, lang:"javascript"](code/javascript/tree.js)
 {% sample lang="py" %}
@@ -205,6 +217,12 @@ utility.h
 [import, lang:"c_cpp"](code/c/utility.h)
 tree_traversal.c
 [import, lang:"c_cpp"](code/c/tree_traversal.c)
+{% sample lang="java" %}
+### Java
+Tree.java
+[import, lang:"java"](code/java/Tree.java)
+MainClass.java
+[import, lang:"java"](code/java/MainClass.java)
 {% sample lang="js" %}
 ### JavaScript
 [import, lang:"javascript"](code/javascript/tree.js)