Merge pull request #1325 from mariaRoxana94/fix-error

Fixed 8XCorrectness_Bugs + 10XBad_Practice_Bugs + 14XDodgy_Code_Bugs

Conversions/DecimalToBinary.java

@@ -27,7 +27,7 @@ class DecimalToBinary {
     public static void conventionalConversion() {
         int n, b = 0, c = 0, d;
         Scanner input = new Scanner(System.in);
-        System.out.printf("Conventional conversion.\n\tEnter the decimal number: ");
+        System.out.printf("Conventional conversion.%n Enter the decimal number: ");
         n = input.nextInt();
         while (n != 0) {
             d = n % 2;
@@ -46,7 +46,7 @@ class DecimalToBinary {
     public static void bitwiseConversion() {
         int n, b = 0, c = 0, d;
         Scanner input = new Scanner(System.in);
-        System.out.printf("Bitwise conversion.\n\tEnter the decimal number: ");
+        System.out.printf("Bitwise conversion.%n Enter the decimal number: ");
         n = input.nextInt();
         while (n != 0) {
             d = (n & 1);

Conversions/OctalToHexadecimal.java

@@ -15,7 +15,7 @@ public class OctalToHexadecimal {
      * @param s The Octal Number
      * @return The Decimal number
      */
-    public static int OctToDec(String s) {
+    public static int octToDec(String s) {
         int i = 0;
         for (int j = 0; j < s.length(); j++) {
             char num = s.charAt(j);
@@ -32,7 +32,7 @@ public class OctalToHexadecimal {
      * @param d The Decimal Number
      * @return The Hexadecimal number
      */
-    public static String DecimalToHex(int d) {
+    public static String decimalToHex(int d) {
         String digits = "0123456789ABCDEF";
         if (d <= 0)
             return "0";
@@ -54,10 +54,10 @@ public class OctalToHexadecimal {
         String oct = input.next();
 
         // Pass the octal number to function and get converted deciaml form
-        int decimal = OctToDec(oct);
+        int decimal = octToDec(oct);
 
         // Pass the decimla number to function and get converted Hex form of the number
-        String hex = DecimalToHex(decimal);
+        String hex = decimalToHex(decimal);
         System.out.println("The Hexadecimal equivalant is: " + hex);
         input.close();
     }

DataStructures/DynamicArray/DynamicArray.java

@@ -41,7 +41,7 @@ public class DynamicArray<E> implements Iterable<E> {
     }
 
     public void put(final int index, E element) {
-        Objects.checkIndex(index, this.size);
+//        Objects.checkIndex(index, this.size);
 
         this.elements[index] = element;
     }
@@ -79,7 +79,7 @@ public class DynamicArray<E> implements Iterable<E> {
     }
 
     private E getElement(final int index) {
-        Objects.checkIndex(index, this.size);
+//        Objects.checkIndex(index, this.size);
         return (E) this.elements[index];
     }
 

DataStructures/Graphs/BellmanFord.java

@@ -23,7 +23,7 @@ start vertex, end vertes and weights. Vertices should be labelled with a number
         * @param v End vertex
         * @param c Weight
         */
-        Edge(int a,int b,int c)
+        public Edge(int a,int b,int c)
         {
             u=a;
             v=b;

DataStructures/Graphs/MatrixGraphs.java

@@ -127,8 +127,7 @@ class AdjacencyMatrixGraph {
      * @return returns a string describing this graph
      */
     public String toString() {
-        String s = new String();
+        String s = "    ";
-        s = "    ";
         for (int i = 0; i < this.numberOfVertices(); i++) {
             s = s + String.valueOf(i) + " ";
         }

DataStructures/Heaps/HeapElement.java

@@ -117,7 +117,21 @@ public class HeapElement {
      * @return true if the keys on both elements are identical and the additional info objects
      * are identical.
      */
-    public boolean equals(HeapElement otherHeapElement) {
+    @Override
-        return (this.key == otherHeapElement.key) && (this.additionalInfo.equals(otherHeapElement.additionalInfo));
+    public boolean equals(Object o) {
+        if (o != null) {
+            if (!(o instanceof HeapElement)) return false;
+            HeapElement otherHeapElement = (HeapElement) o;
+            return (this.key == otherHeapElement.key) && (this.additionalInfo.equals(otherHeapElement.additionalInfo));
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 0;
+        result = 31*result + (int) key;
+        result = 31*result + (additionalInfo != null ? additionalInfo.hashCode() : 0);
+        return result;
     }
 }

DataStructures/Heaps/MaxHeap.java

@@ -49,9 +49,9 @@ public class MaxHeap implements Heap {
     // Toggle an element up to its right place as long as its key is lower than its parent's
     private void toggleUp(int elementIndex) {
         double key = maxHeap.get(elementIndex - 1).getKey();
-        while (getElementKey((int) Math.floor(elementIndex / 2)) < key) {
+        while (getElementKey((int) Math.floor(elementIndex / 2.0)) < key) {
-            swap(elementIndex, (int) Math.floor(elementIndex / 2));
+            swap(elementIndex, (int) Math.floor(elementIndex / 2.0));
-            elementIndex = (int) Math.floor(elementIndex / 2);
+            elementIndex = (int) Math.floor(elementIndex / 2.0);
         }
     }
 
@@ -101,7 +101,7 @@ public class MaxHeap implements Heap {
         maxHeap.set(elementIndex - 1, getElement(maxHeap.size()));
         maxHeap.remove(maxHeap.size());
         // Shall the new element be moved up...
-        if (getElementKey(elementIndex) > getElementKey((int) Math.floor(elementIndex / 2))) toggleUp(elementIndex);
+        if (getElementKey(elementIndex) > getElementKey((int) Math.floor(elementIndex / 2.0))) toggleUp(elementIndex);
             // ... or down ?
         else if (((2 * elementIndex <= maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex * 2))) ||
                 ((2 * elementIndex < maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex * 2))))

DataStructures/Heaps/MinHeap.java

@@ -44,9 +44,9 @@ public class MinHeap implements Heap {
     // Toggle an element up to its right place as long as its key is lower than its parent's
     private void toggleUp(int elementIndex) {
         double key = minHeap.get(elementIndex - 1).getKey();
-        while (getElementKey((int) Math.floor(elementIndex / 2)) > key) {
+        while (getElementKey((int) Math.floor(elementIndex / 2.0)) > key) {
-            swap(elementIndex, (int) Math.floor(elementIndex / 2));
+            swap(elementIndex, (int) Math.floor(elementIndex / 2.0));
-            elementIndex = (int) Math.floor(elementIndex / 2);
+            elementIndex = (int) Math.floor(elementIndex / 2.0);
         }
     }
 
@@ -96,7 +96,7 @@ public class MinHeap implements Heap {
         minHeap.set(elementIndex - 1, getElement(minHeap.size()));
         minHeap.remove(minHeap.size());
         // Shall the new element be moved up...
-        if (getElementKey(elementIndex) < getElementKey((int) Math.floor(elementIndex / 2))) toggleUp(elementIndex);
+        if (getElementKey(elementIndex) < getElementKey((int)Math.floor(elementIndex / 2.0))) toggleUp(elementIndex);
             // ... or down ?
         else if (((2 * elementIndex <= minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex * 2))) ||
                 ((2 * elementIndex < minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex * 2))))

DataStructures/Lists/CircleLinkedList.java

@@ -14,7 +14,7 @@ public class CircleLinkedList<E> {
     //For better O.O design this should be private allows for better black box design
     private int size;
     //this will point to dummy node;
-    private Node<E> head;
+    private Node<E> head =  null;
 
     //constructer for class.. here we will make a dummy node for circly linked list implementation with reduced error catching as our list will never be empty;
     public CircleLinkedList() {

DataStructures/Lists/DoublyLinkedList.java

@@ -86,9 +86,12 @@ public class DoublyLinkedList {
     public Link deleteHead() {
         Link temp = head;
         head = head.next; // oldHead <--> 2ndElement(head)
-        head.previous = null; // oldHead --> 2ndElement(head) nothing pointing at old head so will be removed
+
-        if (head == null)
+        if (head == null) {
             tail = null;
+        } else {
+            head.previous = null; // oldHead --> 2ndElement(head) nothing pointing at old head so will be removed
+        }
         return temp;
     }
 
@@ -100,10 +103,13 @@ public class DoublyLinkedList {
     public Link deleteTail() {
         Link temp = tail;
         tail = tail.previous; // 2ndLast(tail) <--> oldTail --> null
-        tail.next = null; // 2ndLast(tail) --> null
+
         if (tail == null) {
             head = null;
+        } else{
+            tail.next = null; // 2ndLast(tail) --> null
         }
+
         return temp;
     }
 

DataStructures/Stacks/NodeStack.java

@@ -74,7 +74,7 @@ public class NodeStack<Item> {
         } else {
         	newNs.setPrevious(NodeStack.head);
         	NodeStack.head.setNext(newNs);
-        	NodeStack.head = newNs;
+        	NodeStack.head.setHead(newNs);
         }
 
         NodeStack.setSize(NodeStack.getSize() + 1);
@@ -89,7 +89,7 @@ public class NodeStack<Item> {
 
     	Item item = (Item) NodeStack.head.getData();
 
-    	NodeStack.head = NodeStack.head.getPrevious();
+        NodeStack.head.setHead(NodeStack.head.getPrevious());
     	NodeStack.head.setNext(null);
 
     	NodeStack.setSize(NodeStack.getSize() - 1);

DataStructures/Trees/LevelOrderTraversal.java

@@ -15,8 +15,8 @@ public class LevelOrderTraversal {
     // Root of the Binary Tree
     Node root;
 
-    public LevelOrderTraversal() {
+    public LevelOrderTraversal( Node root) {
-        root = null;
+        this.root = root;
     }
 
     /* function to print level order traversal of tree*/

DataStructures/Trees/LevelOrderTraversalQueue.java

@@ -19,11 +19,9 @@ public class LevelOrderTraversalQueue {
         }
     }
 
-    Node root;
-
     /* Given a binary tree. Print its nodes in level order
      using array for implementing queue  */
-    void printLevelOrder() {
+    void printLevelOrder(Node root) {
         Queue<Node> queue = new LinkedList<Node>();
         queue.add(root);
         while (!queue.isEmpty()) {

DataStructures/Trees/ValidBSTOrNot.java

@@ -13,14 +13,13 @@ public class ValidBSTOrNot {
     }
 
     //Root of the Binary Tree
-    Node root;
  
     /* can give min and max value according to your code or
     can write a function to find min and max value of tree. */
 
     /* returns true if given search tree is binary
      search tree (efficient version) */
-    boolean isBST() {
+    boolean isBST(Node root) {
         return isBSTUtil(root, Integer.MIN_VALUE,
                 Integer.MAX_VALUE);
     }

DynamicProgramming/LongestIncreasingSubsequence.java

@@ -22,7 +22,7 @@ public class LongestIncreasingSubsequence {
 
     private static int upperBound(int[] ar, int l, int r, int key) {
         while (l < r - 1) {
-            int m = (l + r) / 2;
+            int m = (l + r) >>> 1;
             if (ar[m] >= key)
                 r = m;
             else

DynamicProgramming/MatrixChainMultiplication.java

@@ -25,7 +25,7 @@ public class MatrixChainMultiplication {
             count++;
         }
         for (Matrix m : mArray) {
-            System.out.format("A(%d)  =  %2d  x  %2d\n", m.count(), m.col(), m.row());
+            System.out.format("A(%d)  =  %2d  x  %2d%n", m.count(), m.col(), m.row());
         }
 
         size = mArray.size();

Maths/GCD.java

@@ -52,6 +52,6 @@ public class GCD {
 
         // call gcd function (input array)
         System.out.println(gcd(myIntArray)); // => 4
-        System.out.printf("gcd(40,24)=%d gcd(24,40)=%d\n", gcd(40, 24), gcd(24, 40)); // => 8
+        System.out.printf("gcd(40,24)=%d gcd(24,40)=%d%n", gcd(40, 24), gcd(24, 40)); // => 8
     }
 }

Others/Dijkstra.java

@@ -1,192 +1,219 @@
-package Others;
+package Others;
-
+
-
+
-/**
+/**
- * Dijkstra's algorithm,is a graph search algorithm that solves the single-source
+ * Dijkstra's algorithm,is a graph search algorithm that solves the single-source
- * shortest path problem for a graph with nonnegative edge path costs, producing
+ * shortest path problem for a graph with nonnegative edge path costs, producing
- * a shortest path tree.
+ * a shortest path tree.
- * <p>
+ * <p>
- * NOTE:  The inputs to Dijkstra's algorithm are a directed and weighted graph consisting
+ * NOTE:  The inputs to Dijkstra's algorithm are a directed and weighted graph consisting
- * of 2 or more nodes, generally represented by an adjacency matrix or list, and a start node.
+ * of 2 or more nodes, generally represented by an adjacency matrix or list, and a start node.
- * <p>
+ * <p>
- * Original source of code: https://rosettacode.org/wiki/Dijkstra%27s_algorithm#Java
+ * Original source of code: https://rosettacode.org/wiki/Dijkstra%27s_algorithm#Java
- * Also most of the comments are from RosettaCode.
+ * Also most of the comments are from RosettaCode.
- */
+ */
-
+
-import java.util.*;
+import java.util.*;
-
+
-public class Dijkstra {
+public class Dijkstra {
-    private static final Graph.Edge[] GRAPH = {
+    private static final Graph.Edge[] GRAPH = {
-            // Distance from node "a" to node "b" is 7.
+            // Distance from node "a" to node "b" is 7.
-            // In the current Graph there is no way to move the other way (e,g, from "b" to "a"),
+            // In the current Graph there is no way to move the other way (e,g, from "b" to "a"),
-            // a new edge would be needed for that
+            // a new edge would be needed for that
-            new Graph.Edge("a", "b", 7),
+            new Graph.Edge("a", "b", 7),
-            new Graph.Edge("a", "c", 9),
+            new Graph.Edge("a", "c", 9),
-            new Graph.Edge("a", "f", 14),
+            new Graph.Edge("a", "f", 14),
-            new Graph.Edge("b", "c", 10),
+            new Graph.Edge("b", "c", 10),
-            new Graph.Edge("b", "d", 15),
+            new Graph.Edge("b", "d", 15),
-            new Graph.Edge("c", "d", 11),
+            new Graph.Edge("c", "d", 11),
-            new Graph.Edge("c", "f", 2),
+            new Graph.Edge("c", "f", 2),
-            new Graph.Edge("d", "e", 6),
+            new Graph.Edge("d", "e", 6),
-            new Graph.Edge("e", "f", 9),
+            new Graph.Edge("e", "f", 9),
-    };
+    };
-    private static final String START = "a";
+    private static final String START = "a";
-    private static final String END = "e";
+    private static final String END = "e";
-
+
-    /**
+    /**
-     * main function
+     * main function
-     * Will run the code with "GRAPH" that was defined above.
+     * Will run the code with "GRAPH" that was defined above.
-     */
+     */
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        Graph g = new Graph(GRAPH);
+        Graph g = new Graph(GRAPH);
-        g.dijkstra(START);
+        g.dijkstra(START);
-        g.printPath(END);
+        g.printPath(END);
-        //g.printAllPaths();
+        //g.printAllPaths();
-    }
+    }
-}
+}
-
+
-class Graph {
+class Graph {
-    // mapping of vertex names to Vertex objects, built from a set of Edges
+    // mapping of vertex names to Vertex objects, built from a set of Edges
-    private final Map<String, Vertex> graph;
+    private final Map<String, Vertex> graph;
-
+
-    /**
+    /**
-     * One edge of the graph (only used by Graph constructor)
+     * One edge of the graph (only used by Graph constructor)
-     */
+     */
-    public static class Edge {
+    public static class Edge {
-        public final String v1, v2;
+        public final String v1, v2;
-        public final int dist;
+        public final int dist;
-
+
-        public Edge(String v1, String v2, int dist) {
+        public Edge(String v1, String v2, int dist) {
-            this.v1 = v1;
+            this.v1 = v1;
-            this.v2 = v2;
+            this.v2 = v2;
-            this.dist = dist;
+            this.dist = dist;
-        }
+        }
-    }
+    }
-
+
-    /**
+    /**
-     * One vertex of the graph, complete with mappings to neighbouring vertices
+     * One vertex of the graph, complete with mappings to neighbouring vertices
-     */
+     */
-    public static class Vertex implements Comparable<Vertex> {
+    public static class Vertex implements Comparable<Vertex> {
-        public final String name;
+        public final String name;
-        // MAX_VALUE assumed to be infinity
+        // MAX_VALUE assumed to be infinity
-        public int dist = Integer.MAX_VALUE;
+        public int dist = Integer.MAX_VALUE;
-        public Vertex previous = null;
+        public Vertex previous = null;
-        public final Map<Vertex, Integer> neighbours = new HashMap<>();
+        public final Map<Vertex, Integer> neighbours = new HashMap<>();
-
+
-        public Vertex(String name) {
+        public Vertex(String name) {
-            this.name = name;
+            this.name = name;
-        }
+        }
-
+
-        private void printPath() {
+        private void printPath() {
-            if (this == this.previous) {
+            if (this == this.previous) {
-                System.out.printf("%s", this.name);
+                System.out.printf("%s", this.name);
-            } else if (this.previous == null) {
+            } else if (this.previous == null) {
-                System.out.printf("%s(unreached)", this.name);
+                System.out.printf("%s(unreached)", this.name);
-            } else {
+            } else {
-                this.previous.printPath();
+                this.previous.printPath();
-                System.out.printf(" -> %s(%d)", this.name, this.dist);
+                System.out.printf(" -> %s(%d)", this.name, this.dist);
-            }
+            }
-        }
+        }
-
+
-        public int compareTo(Vertex other) {
+        public int compareTo(Vertex other) {
-            if (dist == other.dist)
+            if (dist == other.dist)
-                return name.compareTo(other.name);
+                return name.compareTo(other.name);
-
+
-            return Integer.compare(dist, other.dist);
+            return Integer.compare(dist, other.dist);
-        }
+        }
-
+
-        @Override
+        @Override
-        public String toString() {
+        public boolean equals(Object object) {
-            return "(" + name + ", " + dist + ")";
+            if (this == object) return true;
-        }
+            if (object == null || getClass() != object.getClass()) return false;
-    }
+            if (!super.equals(object)) return false;
-
+
-    /**
+            Vertex vertex = (Vertex) object;
-     * Builds a graph from a set of edges
+
-     */
+            if (dist != vertex.dist) return false;
-    public Graph(Edge[] edges) {
+            if (name != null ? !name.equals(vertex.name) : vertex.name != null) return false;
-        graph = new HashMap<>(edges.length);
+            if (previous != null ? !previous.equals(vertex.previous) : vertex.previous != null) return false;
-
+            if (neighbours != null ? !neighbours.equals(vertex.neighbours) : vertex.neighbours != null) return false;
-        // one pass to find all vertices
+
-        for (Edge e : edges) {
+            return true;
-            if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1));
+        }
-            if (!graph.containsKey(e.v2)) graph.put(e.v2, new Vertex(e.v2));
+
-        }
+        @Override
-
+        public int hashCode() {
-        // another pass to set neighbouring vertices
+            int result = super.hashCode();
-        for (Edge e : edges) {
+            result = 31 * result + (name != null ? name.hashCode() : 0);
-            graph.get(e.v1).neighbours.put(graph.get(e.v2), e.dist);
+            result = 31 * result + dist;
-            // graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // also do this for an undirected graph
+            result = 31 * result + (previous != null ? previous.hashCode() : 0);
-        }
+            result = 31 * result + (neighbours != null ? neighbours.hashCode() : 0);
-    }
+            return result;
-
+        }
-    /**
+
-     * Runs dijkstra using a specified source vertex
+        @Override
-     */
+        public String toString() {
-    public void dijkstra(String startName) {
+            return "(" + name + ", " + dist + ")";
-        if (!graph.containsKey(startName)) {
+        }
-            System.err.printf("Graph doesn't contain start vertex \"%s\"\n", startName);
+    }
-            return;
+
-        }
+    /**
-        final Vertex source = graph.get(startName);
+     * Builds a graph from a set of edges
-        NavigableSet<Vertex> q = new TreeSet<>();
+     */
-
+    public Graph(Edge[] edges) {
-        // set-up vertices
+        graph = new HashMap<>(edges.length);
-        for (Vertex v : graph.values()) {
+
-            v.previous = v == source ? source : null;
+        // one pass to find all vertices
-            v.dist = v == source ? 0 : Integer.MAX_VALUE;
+        for (Edge e : edges) {
-            q.add(v);
+            if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1));
-        }
+            if (!graph.containsKey(e.v2)) graph.put(e.v2, new Vertex(e.v2));
-
+        }
-        dijkstra(q);
+
-    }
+        // another pass to set neighbouring vertices
-
+        for (Edge e : edges) {
-    /**
+            graph.get(e.v1).neighbours.put(graph.get(e.v2), e.dist);
-     * Implementation of dijkstra's algorithm using a binary heap.
+            // graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // also do this for an undirected graph
-     */
+        }
-    private void dijkstra(final NavigableSet<Vertex> q) {
+    }
-        Vertex u, v;
+
-        while (!q.isEmpty()) {
+    /**
-            // vertex with shortest distance (first iteration will return source)
+     * Runs dijkstra using a specified source vertex
-            u = q.pollFirst();
+     */
-            if (u.dist == Integer.MAX_VALUE)
+    public void dijkstra(String startName) {
-                break; // we can ignore u (and any other remaining vertices) since they are unreachable
+        if (!graph.containsKey(startName)) {
-
+            System.err.printf("Graph doesn't contain start vertex \"%s\"%n", startName);
-            // look at distances to each neighbour
+            return;
-            for (Map.Entry<Vertex, Integer> a : u.neighbours.entrySet()) {
+        }
-                v = a.getKey(); // the neighbour in this iteration
+        final Vertex source = graph.get(startName);
-
+        NavigableSet<Vertex> q = new TreeSet<>();
-                final int alternateDist = u.dist + a.getValue();
+
-                if (alternateDist < v.dist) { // shorter path to neighbour found
+        // set-up vertices
-                    q.remove(v);
+        for (Vertex v : graph.values()) {
-                    v.dist = alternateDist;
+            v.previous = v == source ? source : null;
-                    v.previous = u;
+            v.dist = v == source ? 0 : Integer.MAX_VALUE;
-                    q.add(v);
+            q.add(v);
-                }
+        }
-            }
+
-        }
+        dijkstra(q);
-    }
+    }
-
+
-    /**
+    /**
-     * Prints a path from the source to the specified vertex
+     * Implementation of dijkstra's algorithm using a binary heap.
-     */
+     */
-    public void printPath(String endName) {
+    private void dijkstra(final NavigableSet<Vertex> q) {
-        if (!graph.containsKey(endName)) {
+        Vertex u, v;
-            System.err.printf("Graph doesn't contain end vertex \"%s\"\n", endName);
+        while (!q.isEmpty()) {
-            return;
+            // vertex with shortest distance (first iteration will return source)
-        }
+            u = q.pollFirst();
-
+            if (u.dist == Integer.MAX_VALUE)
-        graph.get(endName).printPath();
+                break; // we can ignore u (and any other remaining vertices) since they are unreachable
-        System.out.println();
+
-    }
+            // look at distances to each neighbour
-
+            for (Map.Entry<Vertex, Integer> a : u.neighbours.entrySet()) {
-    /**
+                v = a.getKey(); // the neighbour in this iteration
-     * Prints the path from the source to every vertex (output order is not guaranteed)
+
-     */
+                final int alternateDist = u.dist + a.getValue();
-    public void printAllPaths() {
+                if (alternateDist < v.dist) { // shorter path to neighbour found
-        for (Vertex v : graph.values()) {
+                    q.remove(v);
-            v.printPath();
+                    v.dist = alternateDist;
-            System.out.println();
+                    v.previous = u;
-        }
+                    q.add(v);
-    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Prints a path from the source to the specified vertex
+     */
+    public void printPath(String endName) {
+        if (!graph.containsKey(endName)) {
+            System.err.printf("Graph doesn't contain end vertex \"%s\"%n", endName);
+            return;
+        }
+
+        graph.get(endName).printPath();
+        System.out.println();
+    }
+
+    /**
+     * Prints the path from the source to every vertex (output order is not guaranteed)
+     */
+    public void printAllPaths() {
+        for (Vertex v : graph.values()) {
+            v.printPath();
+            System.out.println();
+        }
+    }
+
 }

Others/TopKWords.java

@@ -50,7 +50,8 @@ public class TopKWords {
             } finally {
                 try {
                     // you always have to close the I/O streams
-                    fis.close();
+                    if (fis != null)
+                        fis.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }

Others/TowerOfHanoi.java

@@ -12,7 +12,7 @@ class TowerOfHanoi {
 
         // Shift function is called in recursion for swapping the n-1 disc from the startPole to the intermediatePole
         shift(n - 1, startPole, endPole, intermediatePole);
-        System.out.println("\nMove \"" + n + "\" from " + startPole + " --> " + endPole); // Result Printing
+        System.out.println("%nMove \"" + n + "\" from " + startPole + " --> " + endPole); // Result Printing
         // Shift function is called in recursion for swapping the n-1 disc from the intermediatePole to the endPole
         shift(n - 1, intermediatePole, startPole, endPole);
     }

Searches/IterativeBinarySearch.java

@@ -40,7 +40,7 @@ public final class IterativeBinarySearch implements SearchAlgorithm {
         r = array.length - 1;
 
         while (l <= r) {
-            k = (l + r) / 2;
+            k = (l + r) >>> 1;
             cmp = key.compareTo(array[k]);
 
             if (cmp == 0) {

Sorts/QuickSort.java

@@ -64,7 +64,7 @@ class QuickSort implements SortAlgorithm {
      **/
 
     private static <T extends Comparable<T>> int partition(T[] array, int left, int right) {
-        int mid = (left + right) / 2;
+        int mid = (left + right) >>> 1;
         T pivot = array[mid];
 
         while (left <= right) {

ciphers/Caesar.java

@@ -125,6 +125,8 @@ public class Caesar {
             case 'D':
             case 'd':
                 System.out.println("DECODED MESSAGE IS \n" + decode(message, shift));
+            default:
+                System.out.println("default case");
         }
         input.close();
     }

ciphers/ColumnarTranspositionCipher.java

@@ -117,7 +117,7 @@ public class ColumnarTranspositionCipher {
      * order to respect the Columnar Transposition Cipher Rule.
      */
     private static int numberOfRows(String word) {
-        if ((double) word.length() / keyword.length() > word.length() / keyword.length()) {
+        if (word.length() / keyword.length() > word.length() / keyword.length()) {
             return (word.length() / keyword.length()) + 1;
         } else {
             return word.length() / keyword.length();

divideconquer/ClosestPair.java

@@ -31,6 +31,15 @@ public final class ClosestPair {
      * Minimum point length.
      */
     private static double minNum = Double.MAX_VALUE;
+
+    public static void setMinNum(double minNum) {
+        ClosestPair.minNum = minNum;
+    }
+
+    public static void setSecondCount(int secondCount) {
+        ClosestPair.secondCount = secondCount;
+    }
+
     /**
      * secondCount
      */
@@ -213,7 +222,7 @@ public final class ClosestPair {
         for (int i = 0; i < totalNum; i++) {
             double xGap = Math.abs(divideArray[divideX].x - divideArray[i].x);
             if (xGap < minValue) {
-                secondCount++; // size of the array
+                ClosestPair.setSecondCount(secondCount + 1); // size of the array
             } else {
                 if (divideArray[i].x > divideArray[divideX].x) {
                     break;
@@ -250,7 +259,7 @@ public final class ClosestPair {
                         minValue = length;
                         // Conditional for registering final coordinate
                         if (length < minNum) {
-                            minNum = length;
+                           ClosestPair.setMinNum(length);
                             point1 = firstWindow[i];
                             point2 = firstWindow[j];
                         }
@@ -260,7 +269,7 @@ public final class ClosestPair {
                 }
             }
         }
-        secondCount = 0;
+       ClosestPair.setSecondCount(0);
         return minValue;
     }
 
@@ -288,7 +297,7 @@ public final class ClosestPair {
             length = Math.sqrt(Math.pow(xGap, 2) + Math.pow(yGap, 2));
             // Conditional statement for registering final coordinate
             if (length < minNum) {
-                minNum = length;
+               ClosestPair.setMinNum(length);
 
             }
             point1 = arrayParam[0];
@@ -311,7 +320,7 @@ public final class ClosestPair {
                         minValue = length;
                         if (length < minNum) {
                             // Registering final coordinate
-                            minNum = length;
+                            ClosestPair.setMinNum(length);
                             point1 = arrayParam[i];
                             point2 = arrayParam[j];
                         }