docs: fix typos in comments (#7616)

* docs: fix typos in comments

Fix misspellings found with codespell: reccur/reccuring, positon,
choosed, increate, contantating, and "Hava a Eulerian Path". Also
rename the local variable formater to formatter in MathBuilder.

* docs: fix grammar typos in comments

Fix "tho" -> "to", doubled "of of", "than" -> "then", "it's" -> "its",
"in-order to" -> "in order to", and "a" -> "an" before vowel sounds.

Author: jxpark24

src/main/java/com/thealgorithms/datastructures/lists/DoublyLinkedList.java

@@ -7,7 +7,7 @@
  * <p>
  * A linked list is similar to an array, it holds values. However, links in a
  * linked list do not have indexes. With a linked list you do not need to
- * predetermine it's size as it grows and shrinks as it is edited. This is an
+ * predetermine its size as it grows and shrinks as it is edited. This is an
  * example of a double ended, doubly linked list. Each link references the next
  * link and the previous one.
  *

src/main/java/com/thealgorithms/datastructures/lists/QuickSortLinkedList.java

@@ -20,7 +20,7 @@
  *      List lessThanPivot : 3 -> 1 -> 2 -> 4
  *      List greaterThanPivot : 5 -> 8 -> 10 -> 7 -> 9 -> 6
  *
- *      -> reccur for lessThanPivot and greaterThanPivot
+ *      -> recur for lessThanPivot and greaterThanPivot
  *
  *            lessThanPivot :
  *                current pivot : 3
@@ -32,7 +32,7 @@
  *                 lessThanPivot : null
  *                 greaterThanPivot : 8 -> 10 -> 7 -> 9 -> 6
  *
- *        By following the above pattern, reccuring tree will form like below :
+ *        By following the above pattern, the recursion tree will form like below :
  *
  *        List-> 5 -> 3 -> 8 -> 1 -> 10 -> 2 -> 7 -> 4 -> 9 -> 6
  *
@@ -66,7 +66,7 @@
  *                                       (N)   (N)   (N)   (N)
  *
  *
- *      -> After this the tree will reccur back (or backtrack)
+ *      -> After this the tree will recur back (or backtrack)
  *         and the returning list from left and right subtree will attach
  *         themselves around pivot.
  *         i.e. ,

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

@@ -85,7 +85,7 @@ private void swim(int pos) {
     private void sink(int pos) {
         // Check if node's position is that of parent node
         while (2 * pos <= nItems) {
-            int current = 2 * pos; // Jump to the positon of child node
+            int current = 2 * pos; // Jump to the position of child node
             // Compare both the children for the greater one
             if (current < nItems && queueArray[current] < queueArray[current + 1]) {
                 current++;

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

@@ -35,7 +35,7 @@ public final int constructTree(int[] arr, int start, int end, int index) {
         return this.segTree[index];
     }
 
-    /* A function which will update the value at a index i. This will be called by the
+    /* A function which will update the value at an index i. This will be called by the
     update function internally*/
     private void updateTree(int start, int end, int index, int diff, int segIndex) {
         if (index < start || index > end) {

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

@@ -73,7 +73,7 @@ public static ArrayList<Integer> verticalTraversal(BinaryTree.Node root) {
                 ArrayList<Integer> a = new ArrayList<>();
                 map.put(index.peek(), a);
             }
-            /*For a index, corresponding Node data is added
+            /*For an index, corresponding Node data is added
                          to the respective ArrayList present at that
                          index. */
             map.get(index.peek()).add(queue.peek().data);

src/main/java/com/thealgorithms/io/BufferedReader.java

@@ -108,7 +108,7 @@ public int peek(int n) throws IOException {
 
     /**
      * Removes the already read bytes from the buffer
-     * in-order to make space for new bytes to be filled up.
+     * in order to make space for new bytes to be filled up.
      * <p>
      * This may also do the job to read first time data (the whole buffer is empty)
      */

src/main/java/com/thealgorithms/maths/DigitalRoot.java

@@ -55,7 +55,7 @@ public static int digitalRoot(int n) {
 
     // This function is used for finding the sum of the digits of number
     public static int single(int n) {
-        if (n <= 9) { // if n becomes less than 10 than return n
+        if (n <= 9) { // if n becomes less than 10 then return n
             return n;
         } else {
             return (n % 10) + single(n / 10); // n % 10 for extracting digits one by one

src/main/java/com/thealgorithms/maths/EvilNumber.java

@@ -26,7 +26,7 @@ private static int countOneBits(int number) {
      * Check either {@code number} is an Evil number or Odious number
      *
      * @param number the number
-     * @return {@code true} if {@code number} is an Evil number, otherwise false (in case of of Odious number)
+     * @return {@code true} if {@code number} is an Evil number, otherwise false (in case of Odious number)
      */
     public static boolean isEvilNumber(int number) {
         if (number < 0) {

src/main/java/com/thealgorithms/maths/MathBuilder.java

@@ -481,17 +481,17 @@ public Builder closeParenthesisAndDivide() {
         }
 
         public Builder format(String format) {
-            DecimalFormat formater = new DecimalFormat(format);
-            String num = formater.format(number);
+            DecimalFormat formatter = new DecimalFormat(format);
+            String num = formatter.format(number);
             number = Double.parseDouble(num);
             return this;
         }
 
         public Builder format(int decimalPlace) {
             String pattern = "."
                 + "#".repeat(decimalPlace);
-            DecimalFormat formater = new DecimalFormat(pattern);
-            String num = formater.format(number);
+            DecimalFormat formatter = new DecimalFormat(pattern);
+            String num = formatter.format(number);
             number = Double.parseDouble(num);
             return this;
         }

src/main/java/com/thealgorithms/maths/PollardRho.java

@@ -54,7 +54,7 @@ static int g(int base, int modulus) {
     /**
      * This method returns a non-trivial factor of given integer number
      *
-     * @param number Integer is a integer value whose non-trivial factor is to be found
+     * @param number Integer is an integer value whose non-trivial factor is to be found
      * @return Integer non-trivial factor of number
      * @throws RuntimeException object if GCD of given number cannot be found
      */