Merge branch 'master' into src/main/java/com/thealgorithms/datastructures/trees/AVLSimple.java

Author: alxkm

src/main/java/com/thealgorithms/conversions/TurkishToLatinConversion.java

@@ -16,7 +16,7 @@ private TurkishToLatinConversion() {
      * 2. Replace all turkish characters with their corresponding latin characters
      * 3. Return the converted string
      *
-     * @param param String paramter
+     * @param param String parameter
      * @return String
      */
     public static String convertTurkishToLatin(String param) {

src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java

@@ -160,7 +160,7 @@ public void show(int source, int end,
                 break;
             }
         }
-        if (neg == 0) { // Go ahead and show results of computaion
+        if (neg == 0) { // Go ahead and show results of computation
             System.out.println("Distance is: " + dist[end]);
             System.out.println("Path followed:");
             System.out.print(source + " ");

src/main/java/com/thealgorithms/datastructures/graphs/MatrixGraphs.java

@@ -141,7 +141,7 @@ private int[][] adjacency() {
      *
      * @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
+     * @return whether or not the vertices are adjacent
      */
     private boolean adjacencyOfEdgeDoesExist(int from, int to) {
         return (this.adjacency()[from][to] != AdjacencyMatrixGraph.EDGE_NONE);
@@ -162,7 +162,7 @@ public boolean vertexDoesExist(int aVertex) {
      *
      * @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
+     * @return whether or not the vertices are adjacent
      */
     public boolean edgeDoesExist(int from, int to) {
         if (this.vertexDoesExist(from) && this.vertexDoesExist(to)) {

src/main/java/com/thealgorithms/datastructures/heaps/FibonacciHeap.java

@@ -387,7 +387,7 @@ public class HeapNode {
         private HeapNode parent;
 
         /*
-         * a constructor for a heapNode withe key @param (key)
+         * a constructor for a heapNode with key @param (key)
          * prev == next == this
          * parent == child == null
          */

src/main/java/com/thealgorithms/datastructures/queues/PriorityQueues.java

@@ -9,7 +9,7 @@
  * give numbers that are bigger, a higher priority. Queues in theory have no
  * fixed size but when using an array implementation it does.
  * <p>
- * Additional contibutions made by: PuneetTri(https://github.com/PuneetTri)
+ * Additional contributions made by: PuneetTri(https://github.com/PuneetTri)
  */
 class PriorityQueue {
 
@@ -32,8 +32,8 @@ class PriorityQueue {
 
     PriorityQueue() {
         /* If capacity is not defined, default size of 11 would be used
-         *  capacity=max+1 because we cant access 0th element of PQ, and to
-         *  accomodate (max)th elements we need capacity to be max+1.
+         *  capacity=max+1 because we can't access 0th element of PQ, and to
+         *  accommodate (max)th elements we need capacity to be max+1.
          *  Parent is at position k, child at position (k*2,k*2+1), if we
          *  use position 0 in our queue, its child would be at:
          *  (0*2, 0*2+1) -> (0,0). This is why we start at position 1
@@ -127,7 +127,7 @@ public int remove() {
         if (isEmpty()) {
             throw new RuntimeException("Queue is Empty");
         } else {
-            int max = queueArray[1]; // By defintion of our max-heap, value at queueArray[1] pos is
+            int max = queueArray[1]; // By definition of our max-heap, value at queueArray[1] pos is
                                      // the greatest
 
             // Swap max and last element

src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java

@@ -30,7 +30,7 @@ public BSTRecursiveGeneric() {
     }
 
     /**
-     * Displays the tree is a structed format
+     * Displays the tree is a structured format
      */
     public void prettyDisplay() {
         prettyDisplay(root, 0);

src/main/java/com/thealgorithms/devutils/nodes/SimpleNode.java

@@ -15,7 +15,7 @@ public class SimpleNode<E> extends Node<E> {
     private SimpleNode<E> nextNode;
 
     /**
-     * Empty contructor.
+     * Empty constructor.
      */
     public SimpleNode() {
         super();

src/main/java/com/thealgorithms/devutils/nodes/SimpleTreeNode.java

@@ -11,16 +11,16 @@
 public class SimpleTreeNode<E> extends TreeNode<E> {
 
     /**
-     * Refrence to the child Node on the left.
+     * Reference to the child Node on the left.
      */
     private SimpleTreeNode<E> leftNode;
     /**
-     * Refrence to the child Node on the right.
+     * Reference to the child Node on the right.
      */
     private SimpleTreeNode<E> rightNode;
 
     /**
-     * Empty contructor.
+     * Empty constructor.
      */
     public SimpleTreeNode() {
         super();

src/main/java/com/thealgorithms/devutils/nodes/TreeNode.java

@@ -12,7 +12,7 @@
 public abstract class TreeNode<E> extends Node<E> {
 
     /**
-     * Refernce to the parent Node.
+     * Reference to the parent Node.
      */
     private TreeNode<E> parentNode;
     /**
@@ -21,7 +21,7 @@ public abstract class TreeNode<E> extends Node<E> {
     private int depth;
 
     /**
-     * Empty contructor.
+     * Empty constructor.
      */
     public TreeNode() {
         super();

src/main/java/com/thealgorithms/divideandconquer/ClosestPair.java

@@ -182,7 +182,7 @@ public double closestPair(final Location[] a, final int indexNum) {
 
         double minLeftArea; // Minimum length of left array
         double minRightArea; // Minimum length of right array
-        double minValue; // Minimum lengt
+        double minValue; // Minimum length
 
         minLeftArea = closestPair(leftArray, divideX); // recursive closestPair
         minRightArea = closestPair(rightArray, indexNum - divideX);