Merge branch 'master' into master

Author: siriak

DataStructures/Graphs/MatrixGraphs.java

@@ -5,6 +5,13 @@
 import java.util.ArrayList;
 import java.util.LinkedList;
 
+/**
+ * Implementation of a graph in a matrix form
+ * Also known as an adjacency matrix representation
+ * [Adjacency matrix - Uncyclopedia](https://en.wikipedia.org/wiki/Adjacency_matrix)
+ *
+ * @author Unknown
+ */
 public class MatrixGraphs {
 
   public static void main(String args[]) {
@@ -31,14 +38,35 @@ public static void main(String args[]) {
   }
 }
 
+/**
+ * AdjacencyMatrixGraph Implementation
+ */
 class AdjacencyMatrixGraph {
+  /**
+   * The number of vertices in the graph
+   */
   private int _numberOfVertices;
+
+  /**
+   * The number of edges in the graph
+   */
   private int _numberOfEdges;
+
+  /**
+   * The adjacency matrix for the graph
+   */
   private int[][] _adjacency;
 
+  /**
+   * Static variables to define whether or not an edge exists in the
+   * adjacency matrix
+   */
   static final int EDGE_EXIST = 1;
   static final int EDGE_NONE = 0;
 
+  /**
+   * Constructor
+   */
   public AdjacencyMatrixGraph(int givenNumberOfVertices) {
     this.setNumberOfVertices(givenNumberOfVertices);
     this.setNumberOfEdges(0);
@@ -50,34 +78,77 @@ public AdjacencyMatrixGraph(int givenNumberOfVertices) {
     }
   }
 
+  /**
+   * Updates the number of vertices in the graph
+   *
+   * @param newNumberOfVertices the new number of vertices
+   */
   private void setNumberOfVertices(int newNumberOfVertices) {
     this._numberOfVertices = newNumberOfVertices;
   }
 
+  /**
+   * Getter for `this._numberOfVertices`
+   *
+   * @return the number of vertices in the graph
+   */
   public int numberOfVertices() {
     return this._numberOfVertices;
   }
 
+  /**
+   * Updates the number of edges in the graph
+   *
+   * @param newNumberOfEdges
+   * */
   private void setNumberOfEdges(int newNumberOfEdges) {
     this._numberOfEdges = newNumberOfEdges;
   }
 
+  /**
+   * Getter for `this._numberOfEdges`
+   *
+   * @return the number of edges
+   */
   public int numberOfEdges() {
     return this._numberOfEdges;
   }
 
+  /**
+   * Sets a new matrix as the adjacency matrix
+   *
+   * @param newAdjacency the new adjaceny matrix
+   */
   private void setAdjacency(int[][] newAdjacency) {
     this._adjacency = newAdjacency;
   }
 
+  /**
+   * Getter for the adjacency matrix
+   *
+   * @return the adjacency matrix
+   */
   private int[][] adjacency() {
     return this._adjacency;
   }
 
+  /**
+   * Checks if two vertices are connected by an edge
+   *
+   * @param from the parent vertex to check for adjacency
+   * @param to the child vertex to check for adjacency
+   * @return whether or not the vertices are adjancent
+   */
   private boolean adjacencyOfEdgeDoesExist(int from, int to) {
     return (this.adjacency()[from][to] != AdjacencyMatrixGraph.EDGE_NONE);
   }
 
+  /**
+   * Checks if a particular vertex exists in a graph
+   *
+   * @param aVertex the vertex to check for existence
+   * @return whether or not the vertex exists
+   */
   public boolean vertexDoesExist(int aVertex) {
     if (aVertex >= 0 && aVertex < this.numberOfVertices()) {
       return true;
@@ -86,6 +157,13 @@ public boolean vertexDoesExist(int aVertex) {
     }
   }
 
+  /**
+   * Checks if two vertices are connected by an edge
+   *
+   * @param from the parent vertex to check for adjacency
+   * @param to the child vertex to check for adjacency
+   * @return whether or not the vertices are adjancent
+   */
   public boolean edgeDoesExist(int from, int to) {
     if (this.vertexDoesExist(from) && this.vertexDoesExist(to)) {
       return (this.adjacencyOfEdgeDoesExist(from, to));

DevUtils/Nodes/LargeTreeNode.java

@@ -0,0 +1,72 @@
+package DevUtils.Nodes;
+
+import java.util.Collection;
+
+/**
+ * {@link TreeNode} extension that holds a {@link Collection}
+ * of refrences to child Nodes.
+ * 
+ * @param <E> The type of the data held in the Node.
+ * 
+ * @author <a href="https://github.com/aitorfi">aitorfi</a>
+ */
+public class LargeTreeNode<E> extends TreeNode<E> {
+    /** {@link Collection} that holds the Nodes' child nodes. */
+    private Collection<LargeTreeNode<E>> childNodes;
+
+    /** Empty contructor. */
+    public LargeTreeNode() {
+        super();
+    }
+
+    /**
+     * Initializes the Nodes' data.
+     * 
+     * @param data Value to which data will be initialized.
+     * @see TreeNode#TreeNode(Object)
+     */
+    public LargeTreeNode(E data) {
+        super(data);
+    }
+
+    /**
+     * Initializes the Nodes' data and parent node reference.
+     * 
+     * @param data Value to which data will be initialized.
+     * @param parentNode Value to which the nodes' parent reference will be set.
+     * @see TreeNode#TreeNode(Object, Node)
+     */
+    public LargeTreeNode(E data, LargeTreeNode<E> parentNode) {
+        super(data, parentNode);
+    }
+
+    /**
+     * Initializes the Nodes' data and parent and child nodes references.
+     * 
+     * @param data Value to which data will be initialized.
+     * @param parentNode Value to which the nodes' parent reference will be set.
+     * @param childNodes {@link Collection} of child Nodes.
+     * @see TreeNode#TreeNode(Object, Node)
+     */
+    public LargeTreeNode(E data, LargeTreeNode<E> parentNode, Collection<LargeTreeNode<E>> childNodes) {
+        super(data, parentNode);
+        this.childNodes = childNodes;
+    }
+
+    /**
+     * @return True if the node is a leaf node, otherwise false.
+     * @see TreeNode#isLeafNode()
+     */
+    @Override
+    public boolean isLeafNode() {
+        return (childNodes == null || childNodes.size() == 0);
+    }
+
+    public Collection<LargeTreeNode<E>> getChildNodes() {
+        return childNodes;
+    }
+
+    public void setChildNodes(Collection<LargeTreeNode<E>> childNodes) {
+        this.childNodes = childNodes;
+    }
+}

DevUtils/Nodes/Node.java

@@ -0,0 +1,36 @@
+package DevUtils.Nodes;
+
+/**
+ * Base class for any node implementation which
+ * contains a generic type variable.
+ * 
+ * All known subclasses: {@link TreeNode}, {@link SimpleNode}.
+ * 
+ * @param <E> The type of the data held in the Node.
+ * 
+ * @author <a href="https://github.com/aitorfi">aitorfi</a>
+ */
+public abstract class Node<E> {
+    /** Generic type data stored in the Node. */
+    private E data;
+
+    /** Empty constructor. */
+    public Node() {}
+
+    /**
+     * Initializes the Nodes' data.
+     * 
+     * @param data Value to which data will be initialized.
+     */
+    public Node(E data) {
+        this.data = data;
+    }
+
+    public E getData() {
+        return data;
+    }
+
+    public void setData(E data) {
+        this.data = data;
+    }
+}

DevUtils/Nodes/SimpleNode.java

@@ -0,0 +1,55 @@
+package DevUtils.Nodes;
+
+/**
+ * Simple Node implementation that holds
+ * a reference to the next Node.
+ * 
+ * @param <E> The type of the data held in the Node.
+ * 
+ * @author <a href="https://github.com/aitorfi">aitorfi</a>
+ */
+public class SimpleNode<E> extends Node<E> {
+    /** Reference to the next Node. */
+    private SimpleNode<E> nextNode;
+
+    /** Empty contructor. */
+    public SimpleNode() {
+        super();
+    }
+
+    /**
+     * Initializes the Nodes' data.
+     * 
+     * @param data Value to which data will be initialized.
+     * @see Node#Node(Object)
+     */
+    public SimpleNode(E data) {
+        super(data);
+    }
+
+    /**
+     * Initializes the Nodes' data and next node reference.
+     * 
+     * @param data Value to which data will be initialized.
+     * @param nextNode Value to which the next node reference will be set.
+     */
+    public SimpleNode(E data, SimpleNode<E> nextNode) {
+        super(data);
+        this.nextNode = nextNode;
+    }
+
+    /**
+     * @return True if there is a next node, otherwise false.
+     */
+    public boolean hasNext() {
+        return (nextNode != null);
+    }
+
+    public SimpleNode<E> getNextNode() {
+        return nextNode;
+    }
+
+    public void setNextNode(SimpleNode<E> nextNode) {
+        this.nextNode = nextNode;
+    }
+}

DevUtils/Nodes/SimpleTreeNode.java

@@ -0,0 +1,81 @@
+package DevUtils.Nodes;
+
+/**
+ * Simple TreeNode extension that holds references
+ * to two child Nodes (left and right).
+ * 
+ * @param <E> The type of the data held in the Node.
+ * 
+ * @author <a href="https://github.com/aitorfi">aitorfi</a>
+ */
+public class SimpleTreeNode<E> extends TreeNode<E> {
+    /** Refrence to the child Node on the left. */
+    private SimpleTreeNode<E> leftNode;
+    /** Refrence to the child Node on the right. */
+    private SimpleTreeNode<E> rightNode;
+
+    /** Empty contructor. */
+    public SimpleTreeNode() {
+        super();
+    }
+
+    /**
+     * Initializes the Nodes' data.
+     * 
+     * @param data Value to which data will be initialized.
+     * @see TreeNode#TreeNode(Object)
+     */
+    public SimpleTreeNode(E data) {
+        super(data);
+    }
+
+    /**
+     * Initializes the Nodes' data and parent node reference.
+     * 
+     * @param data Value to which data will be initialized.
+     * @param parentNode Value to which the nodes' parent reference will be set.
+     * @see TreeNode#TreeNode(Object, Node)
+     */
+    public SimpleTreeNode(E data, SimpleTreeNode<E> parentNode) {
+        super(data, parentNode);
+    }
+
+    /**
+     * Initializes the Nodes' data and parent and child nodes references.
+     * 
+     * @param data Value to which data will be initialized.
+     * @param parentNode Value to which the nodes' parent reference will be set.
+     * @param leftNode Value to which the nodes' left child reference will be set.
+     * @param rightNode Value to which the nodes' right child reference will be set.
+     */
+    public SimpleTreeNode(E data, SimpleTreeNode<E> parentNode, SimpleTreeNode<E> leftNode, SimpleTreeNode<E> rightNode) {
+        super(data, parentNode);
+        this.leftNode = leftNode;
+        this.rightNode = rightNode;
+    }
+
+    /**
+     * @return True if the node is a leaf node, otherwise false.
+     * @see TreeNode#isLeafNode()
+     */
+    @Override
+    public boolean isLeafNode() {
+        return (leftNode == null && rightNode == null);
+    }
+
+    public SimpleTreeNode<E> getLeftNode() {
+        return leftNode;
+    }
+
+    public void setLeftNode(SimpleTreeNode<E> leftNode) {
+        this.leftNode = leftNode;
+    }
+
+    public SimpleTreeNode<E> getRightNode() {
+        return rightNode;
+    }
+
+    public void setRightNode(SimpleTreeNode<E> rightNode) {
+        this.rightNode = rightNode;
+    }
+}