Merge branch 'master' of https://github.com/eugenp/tutorials

data-structures/src/main/java/com/baeldung/graph/Graph.java

@@ -0,0 +1,72 @@
+package com.baeldung.graph;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+
+public class Graph {
+
+    private Map<Integer, List<Integer>> adjVertices;
+
+    public Graph() {
+        this.adjVertices = new HashMap<Integer, List<Integer>>();
+    }
+
+    public void addVertex(int vertex) {
+        adjVertices.putIfAbsent(vertex, new ArrayList<>());
+    }
+
+    public void addEdge(int src, int dest) {
+        adjVertices.get(src).add(dest);
+    }
+
+    public void dfsWithoutRecursion(int start) {
+        Stack<Integer> stack = new Stack<Integer>();
+        boolean[] isVisited = new boolean[adjVertices.size()];
+        stack.push(start);
+        while (!stack.isEmpty()) {
+            int current = stack.pop();
+            isVisited[current] = true;
+            System.out.print(" " + current);
+            for (int dest : adjVertices.get(current)) {
+                if (!isVisited[dest])
+                    stack.push(dest);
+            }
+        }
+    }
+
+    public void dfs(int start) {
+        boolean[] isVisited = new boolean[adjVertices.size()];
+        dfsRecursive(start, isVisited);
+    }
+
+    private void dfsRecursive(int current, boolean[] isVisited) {
+        isVisited[current] = true;
+        System.out.print(" " + current);
+        for (int dest : adjVertices.get(current)) {
+            if (!isVisited[dest])
+                dfsRecursive(dest, isVisited);
+        }
+    }
+
+    public void topologicalSort(int start) {
+        Stack<Integer> result = new Stack<Integer>();
+        boolean[] isVisited = new boolean[adjVertices.size()];
+        topologicalSortRecursive(start, isVisited, result);
+        while (!result.isEmpty()) {
+            System.out.print(" " + result.pop());
+        }
+    }
+
+    private void topologicalSortRecursive(int current, boolean[] isVisited, Stack<Integer> result) {
+        isVisited[current] = true;
+        for (int dest : adjVertices.get(current)) {
+            if (!isVisited[dest])
+                topologicalSortRecursive(dest, isVisited, result);
+        }
+        result.push(current);
+    }
+
+}

data-structures/src/main/java/com/baeldung/tree/BinaryTree.java

@@ -2,6 +2,7 @@ package com.baeldung.tree;
 
 import java.util.LinkedList;
 import java.util.Queue;
+import java.util.Stack;
 
 public class BinaryTree {
 
@@ -147,6 +148,68 @@ public class BinaryTree {
         }
     }
 
+    
+    public void traverseInOrderWithoutRecursion() {
+        Stack<Node> stack = new Stack<Node>();
+        Node current = root;
+        stack.push(root);
+        while(! stack.isEmpty()) {
+            while(current.left != null) {
+                current = current.left;                
+                stack.push(current);                
+            }
+            current = stack.pop();
+            System.out.print(" " + current.value);
+            if(current.right != null) {
+                current = current.right;                
+                stack.push(current);
+            }
+        }
+    }
+    
+    public void traversePreOrderWithoutRecursion() {
+        Stack<Node> stack = new Stack<Node>();
+        Node current = root;
+        stack.push(root);
+        while(! stack.isEmpty()) {
+            current = stack.pop();
+            System.out.print(" " + current.value);
+            
+            if(current.right != null)
+                stack.push(current.right);
+                
+            if(current.left != null)
+                stack.push(current.left);
+        }        
+    }
+    
+    public void traversePostOrderWithoutRecursion() {
+        Stack<Node> stack = new Stack<Node>();
+        Node prev = root;
+        Node current = root;
+        stack.push(root);
+
+        while (!stack.isEmpty()) {
+            current = stack.peek();
+            boolean hasChild = (current.left != null || current.right != null);
+            boolean isPrevLastChild = (prev == current.right || (prev == current.left && current.right == null));
+
+            if (!hasChild || isPrevLastChild) {
+                current = stack.pop();
+                System.out.print(" " + current.value);
+                prev = current;
+            } else {
+                if (current.right != null) {
+                    stack.push(current.right);
+                }
+                if (current.left != null) {
+                    stack.push(current.left);
+                }
+            }
+        }   
+    }    
+    
+    
     class Node {
         int value;
         Node left;

data-structures/src/test/java/com/baeldung/graph/GraphUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.graph;
+
+import org.junit.Test;
+
+public class GraphUnitTest {
+
+    @Test
+    public void givenDirectedGraph_whenDFS_thenPrintAllValues() {
+        Graph graph = createDirectedGraph();
+        graph.dfs(0);
+        System.out.println();
+        graph.dfsWithoutRecursion(0);
+    }
+
+    @Test
+    public void givenDirectedGraph_whenGetTopologicalSort_thenPrintValuesSorted() {
+        Graph graph = createDirectedGraph();
+        graph.topologicalSort(0);
+    }
+
+    private Graph createDirectedGraph() {
+        Graph graph = new Graph();
+        graph.addVertex(0);
+        graph.addVertex(1);
+        graph.addVertex(2);
+        graph.addVertex(3);
+        graph.addVertex(4);
+        graph.addVertex(5);
+        graph.addEdge(0, 1);
+        graph.addEdge(0, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 4);
+        graph.addEdge(4, 5);
+        return graph;
+    }
+}

data-structures/src/test/java/com/baeldung/tree/BinaryTreeUnitTest.java

@@ -87,6 +87,8 @@ public class BinaryTreeUnitTest {
         BinaryTree bt = createBinaryTree();
 
         bt.traverseInOrder(bt.root);
+        System.out.println();
+        bt.traverseInOrderWithoutRecursion();
     }
 
     @Test
@@ -95,6 +97,8 @@ public class BinaryTreeUnitTest {
         BinaryTree bt = createBinaryTree();
 
         bt.traversePreOrder(bt.root);
+        System.out.println();
+        bt.traversePreOrderWithoutRecursion();
     }
 
     @Test
@@ -103,6 +107,8 @@ public class BinaryTreeUnitTest {
         BinaryTree bt = createBinaryTree();
 
         bt.traversePostOrder(bt.root);
+        System.out.println();
+        bt.traversePostOrderWithoutRecursion();
     }
 
     @Test