updated

added new algorithms, updated existing algorithms

Author: jbhattac

ArrayPerformanceTest.java

@@ -0,0 +1,44 @@
+package ds.algo.solutions;
+
+public class ArrayPerformanceTest {
+
+	public static int[][] getArray(int rows, int cols) {
+		int[][] arr = new int[rows][cols];
+		
+		for (int i = 0; i < rows; i++) {
+			for (int j = 0; j < cols; j++) {
+				arr[i][j] = 1;
+			}
+		}
+		
+		return arr;
+	}
+	
+	public static void main(String[] args) {
+		
+		int rows = 10000;
+		int cols = 30000;
+		int[][] arr = getArray(rows, cols);
+		
+		long start = System.currentTimeMillis();
+		int sum = 0;
+		for (int i = 0; i < rows; i++) {
+			for (int j = 0; j < cols; j++) {
+				sum += arr[i][j];
+			}
+		}
+		long timeTaken = System.currentTimeMillis() - start;
+		System.out.println("Sum: " + sum + " Time taken: " + timeTaken + " mills");
+		
+		
+		start = System.currentTimeMillis();
+		sum = 0;
+		for (int i = 0; i < cols; i++) {
+			for (int j = 0; j < rows; j++) {
+				sum += arr[j][i];
+			}
+		}
+		timeTaken = System.currentTimeMillis() - start;
+		System.out.println("Sum: " + sum + " Time taken: " + timeTaken + " mills");
+	}
+}

DetectCycleInDirectedGraph.java

@@ -1,4 +1,4 @@
-package ds.algo.solution;
+package ds.algo.solutions;
 
 import java.util.HashSet;
 import java.util.Set;

MergeSort.java

@@ -52,7 +52,7 @@ private void merge(Integer[] integers, int l, int m, int r) {
 	}
 
 	public static void main(String[] args) {
-		Integer[] arr = new Integer[] {0, 9, 7, 6, 1, 3, 5, 2, 4, 8};
+		Integer[] arr = new Integer[] {38, 27, 43, 3, 9, 82, 10};
 		new MergeSort().mergeSort(arr, 0, arr.length - 1);
 		Stream.of(arr).forEach(System.out::println);
 	}

MergeArraysSorted.java renamed to MergeTwoSortedArray.java

@@ -1,6 +1,6 @@
-package ds.algo.solution;
+package ds.algo.solutions;
 
-public class MergeArraysSorted {
+public class MergeTwoSortedArray {
 
 	public int[] merge(int[] arr1, int[] arr2) {
 
@@ -33,4 +33,14 @@ public int[] merge(int[] arr1, int[] arr2) {
 
 		return resultArr;
 	}
+	
+	public static void main(String[] args) {
+		int[] arr1 = new int[] {2, 6, 8, 41};
+		int[] arr2 = new int[] {20, 60, 80, 90};
+		
+		int a[] = new MergeTwoSortedArray().merge(arr1, arr2);
+		for(int i : a) {
+			System.out.println(i);
+		}
+	}
 }

TopologicalSort.java

@@ -1,4 +1,4 @@
-package ds.algo.solution;
+package ds.algo.solutions;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -33,20 +33,17 @@ public static void main(String[] args) {
 		nodes.add(g);
 
 		Stack<TopoNode> stack = new TopologicalSort().topoSort(nodes);
-		while(!stack.isEmpty()) {
-			System.out.println(stack.pop());
-		}
+		
+		stack.forEach(item -> System.out.println(item));
 	}
 
 	private Stack<TopoNode> topoSort(Set<TopoNode> nodes) {
 		Stack<TopoNode> topoStack = new Stack<>();
 		Set<TopoNode> visited = new HashSet<>();
 		Set<TopoNode> allNodes = new HashSet<>(nodes);
 
-		for (TopoNode topoNode : allNodes) {
-			sort(topoNode, topoStack, visited);
-		}
-		
+		allNodes.forEach(node -> sort(node, topoStack, visited));
+				
 		return topoStack;
 	}
 
@@ -55,9 +52,8 @@ private void sort(TopoNode node, Stack<TopoNode> topoStack, Set<TopoNode> visite
 			return;
 		}
 		visited.add(node);
-		for (TopoNode childNode : node.getChildren()) {
-			sort(childNode, topoStack, visited);
-		}
+		node.getChildren().forEach(child -> sort(child, topoStack, visited));
+		
 		topoStack.add(node);
 	}
 }

TreeTraversalDemo.java

@@ -7,30 +7,38 @@
 public class TreeTraversalDemo {
 
 	public static void main(String[] args) {
-		TreeNode one = new TreeNode(1);
-		TreeNode two = new TreeNode(2);
-		TreeNode three = new TreeNode(3);
-		TreeNode four = new TreeNode(4);
-		TreeNode five = new TreeNode(5);
+		TreeNode a = new TreeNode("A");
+		TreeNode b = new TreeNode("B");
+		TreeNode c = new TreeNode("C");
+		TreeNode d = new TreeNode("D");
+		TreeNode e = new TreeNode("E");
+		TreeNode f = new TreeNode("F");
 
-		one.addLeft(two).addRight(three);
-		two.addLeft(four).addRight(five);
-
-		TreeNode root = one;
+		a.addLeft(b).addRight(f);
+		b.addLeft(d).addRight(e);
+		f.addLeft(c);
+		
+		TreeNode root = a;
 		TreeTraversalDemo traversal = new TreeTraversalDemo();
-		System.out.println("level order");
-		traversal.levelOrder(root);
+		traversal.printTree(root, 0);
 
 		System.out.println("in order");
 		traversal.inOrder(root);
 
-		System.out.println("post order");
-		traversal.postOrder(root);
-		
 		System.out.println("pre order");
 		traversal.preOrder(root);
 	}
 
+	private static int treeHeight(TreeNode node) {
+		if (node == null) {
+			return 0;
+		}
+		int l = treeHeight(node.left);
+		int r = treeHeight(node.right);
+		
+		return Math.max(l, r) + 1;
+	}
+
 	public void levelOrder(TreeNode root) {
 		Queue<TreeNode> queue = new LinkedList<>();
 		queue.add(root);
@@ -106,7 +114,6 @@ public void preOrderNonRecursive(TreeNode node) {
 				stack.add(temp.right);
 			if (temp.left != null)
 				stack.add(temp.left);
-			
 		}
 	}
 
@@ -124,17 +131,27 @@ public void postOrderNonRecursive(TreeNode node) {
 			return;
 		}
 	}
+	
+	public void printTree(TreeNode node, int level) {
+		if (node == null) {
+			return;
+		}
+		for (int i = 0; i < level; i++) System.out.print("-");
+		System.out.println(node);
+		printTree(node.left, level + 1);
+		printTree(node.right, level + 1);
+	}
 }
 
 class TreeNode {
 
-	int value;
+	String value;
 
 	TreeNode left;
 
 	TreeNode right;
 
-	TreeNode(int val) {
+	TreeNode(String val) {
 		this.value = val;
 		this.left = null;
 		this.right = null;
@@ -152,6 +169,6 @@ public TreeNode addRight(TreeNode n) {
 
 	@Override
 	public String toString() {
-		return String.valueOf(this.value);
+		return this.value;
 	}
 }