Merge branch 'master' into master

Author: sherlockwayne

DIRECTORY.md

@@ -94,6 +94,7 @@
             * [HexToOct](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/HexToOct.java)
             * [IntegerToEnglish](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/IntegerToEnglish.java)
             * [IntegerToRoman](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/IntegerToRoman.java)
+            * [IPConverter](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/IPConverter.java)
             * [OctalToBinary](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/OctalToBinary.java)
             * [OctalToDecimal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/OctalToDecimal.java)
             * [OctalToHexadecimal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/conversions/OctalToHexadecimal.java)
@@ -598,7 +599,9 @@
             * [MaximumMinimumWindow](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/MaximumMinimumWindow.java)
             * [NextGreaterElement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/NextGreaterElement.java)
             * [NextSmallerElement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/NextSmallerElement.java)
+            * [PostfixEvaluator](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PostfixEvaluator.java)
             * [PostfixToInfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PostfixToInfix.java)
+            * [PrefixEvaluator](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PrefixEvaluator.java)
             * [PrefixToInfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PrefixToInfix.java)
             * [SortStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/SortStack.java)
             * [StackPostfixNotation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/StackPostfixNotation.java)
@@ -725,6 +728,7 @@
             * [HexToOctTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/HexToOctTest.java)
             * [IntegerToEnglishTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/IntegerToEnglishTest.java)
             * [IntegerToRomanTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/IntegerToRomanTest.java)
+            * [IPConverterTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/IPConverterTest.java)
             * [OctalToBinaryTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/OctalToBinaryTest.java)
             * [OctalToDecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/OctalToDecimalTest.java)
             * [OctalToHexadecimalTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/conversions/OctalToHexadecimalTest.java)
@@ -1128,7 +1132,9 @@
             * [LargestRectangleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/LargestRectangleTest.java)
             * [NextGreaterElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/NextGreaterElementTest.java)
             * [NextSmallerElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/NextSmallerElementTest.java)
+            * [PostfixEvaluatorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PostfixEvaluatorTest.java)
             * [PostfixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PostfixToInfixTest.java)
+            * [PrefixEvaluatorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PrefixEvaluatorTest.java)
             * [PrefixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PrefixToInfixTest.java)
             * [SortStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/SortStackTest.java)
             * [StackPostfixNotationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/StackPostfixNotationTest.java)

src/main/java/com/thealgorithms/bitmanipulation/BcdConversion.java

@@ -1,56 +1,80 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * This class provides methods to convert between BCD (Binary-Coded Decimal) and binary.
+ * This class provides methods to convert between BCD (Binary-Coded Decimal) and decimal numbers.
  *
- * Binary-Coded Decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of binary digits, usually four or eight.
+ * BCD is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of binary digits, usually four or eight.
  *
  * For more information, refer to the
  * <a href="https://en.wikipedia.org/wiki/Binary-coded_decimal">Binary-Coded Decimal</a> Wikipedia page.
  *
  * <b>Example usage:</b>
  * <pre>
- * int binary = BcdConversion.bcdToBinary(0x1234);
- * System.out.println("BCD 0x1234 to binary: " + binary); // Output: 1234
+ * int decimal = BcdConversion.bcdToDecimal(0x1234);
+ * System.out.println("BCD 0x1234 to decimal: " + decimal); // Output: 1234
  *
- * int bcd = BcdConversion.binaryToBcd(1234);
- * System.out.println("Binary 1234 to BCD: " + Integer.toHexString(bcd)); // Output: 0x1234
+ * int bcd = BcdConversion.decimalToBcd(1234);
+ * System.out.println("Decimal 1234 to BCD: " + Integer.toHexString(bcd)); // Output: 0x1234
  * </pre>
  */
 public final class BcdConversion {
     private BcdConversion() {
     }
+
     /**
-     * Converts a BCD (Binary-Coded Decimal) number to binary.
+     * Converts a BCD (Binary-Coded Decimal) number to a decimal number.
+     * <p>Steps:
+     * <p>1. Validate the BCD number to ensure all digits are between 0 and 9.
+     * <p>2. Extract the last 4 bits (one BCD digit) from the BCD number.
+     * <p>3. Multiply the extracted digit by the corresponding power of 10 and add it to the decimal number.
+     * <p>4. Shift the BCD number right by 4 bits to process the next BCD digit.
+     * <p>5. Repeat steps 1-4 until the BCD number is zero.
      *
      * @param bcd The BCD number.
-     * @return The corresponding binary number.
+     * @return The corresponding decimal number.
+     * @throws IllegalArgumentException if the BCD number contains invalid digits.
      */
-    public static int bcdToBinary(int bcd) {
-        int binary = 0;
+    public static int bcdToDecimal(int bcd) {
+        int decimal = 0;
         int multiplier = 1;
+
+        // Validate BCD digits
         while (bcd > 0) {
-            int digit = bcd & 0xF; // Extract the last 4 bits (one BCD digit)
-            binary += digit * multiplier;
+            int digit = bcd & 0xF;
+            if (digit > 9) {
+                throw new IllegalArgumentException("Invalid BCD digit: " + digit);
+            }
+            decimal += digit * multiplier;
             multiplier *= 10;
-            bcd >>= 4; // Shift right by 4 bits to process the next BCD digit
+            bcd >>= 4;
         }
-        return binary;
+        return decimal;
     }
 
     /**
-     * Converts a binary number to BCD (Binary-Coded Decimal).
+     * Converts a decimal number to BCD (Binary-Coded Decimal).
+     * <p>Steps:
+     * <p>1. Check if the decimal number is within the valid range for BCD (0 to 9999).
+     * <p>2. Extract the last decimal digit from the decimal number.
+     * <p>3. Shift the digit to the correct BCD position and add it to the BCD number.
+     * <p>4. Remove the last decimal digit from the decimal number.
+     * <p>5. Repeat steps 2-4 until the decimal number is zero.
      *
-     * @param binary The binary number.
+     * @param decimal The decimal number.
      * @return The corresponding BCD number.
+     * @throws IllegalArgumentException if the decimal number is greater than 9999.
      */
-    public static int binaryToBcd(int binary) {
+    public static int decimalToBcd(int decimal) {
+        if (decimal < 0 || decimal > 9999) {
+            throw new IllegalArgumentException("Value out of bounds for BCD representation: " + decimal);
+        }
+
         int bcd = 0;
         int shift = 0;
-        while (binary > 0) {
-            int digit = binary % 10; // Extract the last decimal digit
-            bcd |= (digit << (shift * 4)); // Shift the digit to the correct BCD position
-            binary /= 10; // Remove the last decimal digit
+        while (decimal > 0) {
+            int digit = decimal % 10;
+            bcd |= (digit << (shift * 4));
+            decimal /= 10;
             shift++;
         }
         return bcd;

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

@@ -0,0 +1,58 @@
+package com.thealgorithms.conversions;
+
+/**
+ * Converts an IPv4 address to its binary equivalent and vice-versa.
+ * IP to Binary: Converts an IPv4 address to its binary equivalent.
+ * Example: 127.3.4.5 -> 01111111.00000011.00000100.00000101
+ *
+ * Binary to IP: Converts a binary equivalent to an IPv4 address.
+ * Example: 01111111.00000011.00000100.00000101 -> 127.3.4.5
+ *
+ * @author Hardvan
+ */
+public final class IPConverter {
+    private IPConverter() {
+    }
+
+    /**
+     * Converts an IPv4 address to its binary equivalent.
+     * @param ip The IPv4 address to convert.
+     * @return The binary equivalent of the IPv4 address.
+     */
+    public static String ipToBinary(String ip) {
+        StringBuilder binary = new StringBuilder();
+        for (String octet : ip.split("\\.")) {
+            binary.append(octetToBinary(Integer.parseInt(octet))).append(".");
+        }
+        return binary.substring(0, binary.length() - 1);
+    }
+
+    /**
+     * Converts a single octet to its 8-bit binary representation.
+     * @param octet The octet to convert (0-255).
+     * @return The 8-bit binary representation as a String.
+     */
+    private static String octetToBinary(int octet) {
+        char[] binary = {'0', '0', '0', '0', '0', '0', '0', '0'};
+        for (int i = 7; i >= 0; i--) {
+            if ((octet & 1) == 1) {
+                binary[i] = '1';
+            }
+            octet >>>= 1;
+        }
+        return new String(binary);
+    }
+
+    /**
+     * Converts a binary equivalent to an IPv4 address.
+     * @param binary The binary equivalent to convert.
+     * @return The IPv4 address of the binary equivalent.
+     */
+    public static String binaryToIP(String binary) {
+        StringBuilder ip = new StringBuilder();
+        for (String octet : binary.split("\\.")) {
+            ip.append(Integer.parseInt(octet, 2)).append(".");
+        }
+        return ip.substring(0, ip.length() - 1);
+    }
+}

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

@@ -6,7 +6,6 @@
 class Cycle {
 
     private final int nodes;
-    private final int edges;
     private int[][] adjacencyMatrix;
     private boolean[] visited;
     ArrayList<ArrayList<Integer>> cycles = new ArrayList<ArrayList<Integer>>();
@@ -16,7 +15,7 @@ class Cycle {
         System.out.print("Enter the no. of nodes: ");
         nodes = in.nextInt();
         System.out.print("Enter the no. of Edges: ");
-        edges = in.nextInt();
+        final int edges = in.nextInt();
 
         adjacencyMatrix = new int[nodes][nodes];
         visited = new boolean[nodes];

src/main/java/com/thealgorithms/others/CRCAlgorithm.java

@@ -25,8 +25,6 @@ public class CRCAlgorithm {
 
     private ArrayList<Integer> message;
 
-    private ArrayList<Integer> dividedMessage;
-
     private ArrayList<Integer> p;
 
     private Random randomGenerator;
@@ -44,7 +42,6 @@ public CRCAlgorithm(String str, int size, double ber) {
         messageChanged = false;
         message = new ArrayList<>();
         messSize = size;
-        dividedMessage = new ArrayList<>();
         p = new ArrayList<>();
         for (int i = 0; i < str.length(); i++) {
             p.add(Character.getNumericValue(str.charAt(i)));
@@ -103,7 +100,6 @@ public int getCorrectMess() {
     public void refactor() {
         messageChanged = false;
         message = new ArrayList<>();
-        dividedMessage = new ArrayList<>();
     }
 
     /**
@@ -156,7 +152,7 @@ public void divideMessageWithP(boolean check) {
                 }
             }
         }
-        dividedMessage = (ArrayList<Integer>) x.clone();
+        ArrayList<Integer> dividedMessage = (ArrayList<Integer>) x.clone();
         if (!check) {
             message.addAll(dividedMessage);
         } else {

src/main/java/com/thealgorithms/sorts/LinkListSort.java

@@ -259,14 +259,12 @@ static int count(Node head) {
 
 class Task2 {
 
-    private int[] a;
-
     public Node sortByHeapSort(Node head) {
         if (head == null || head.next == null) {
             return head;
         }
         int c = count(head);
-        a = new int[c];
+        int[] a = new int[c];
         // Array of size c is created
         int i = 0;
         for (Node ptr = head; ptr != null; ptr = ptr.next) {

src/main/java/com/thealgorithms/stacks/PostfixEvaluator.java

@@ -0,0 +1,74 @@
+package com.thealgorithms.stacks;
+
+import java.util.Set;
+import java.util.Stack;
+
+/**
+ * Evaluate a postfix (Reverse Polish) expression using a stack.
+ *
+ * <p>Example: Expression "5 6 + 2 *" results in 22.
+ * <p>Applications: Used in calculators and expression evaluation in compilers.
+ *
+ * @author Hardvan
+ */
+public final class PostfixEvaluator {
+    private PostfixEvaluator() {
+    }
+
+    private static final Set<String> OPERATORS = Set.of("+", "-", "*", "/");
+
+    /**
+     * Evaluates the given postfix expression and returns the result.
+     *
+     * @param expression The postfix expression as a string with operands and operators separated by spaces.
+     * @return The result of evaluating the postfix expression.
+     * @throws IllegalArgumentException if the expression is invalid.
+     */
+    public static int evaluatePostfix(String expression) {
+        Stack<Integer> stack = new Stack<>();
+
+        for (String token : expression.split("\\s+")) {
+            if (isOperator(token)) {
+                int operand2 = stack.pop();
+                int operand1 = stack.pop();
+                stack.push(applyOperator(token, operand1, operand2));
+            } else {
+                stack.push(Integer.valueOf(token));
+            }
+        }
+
+        if (stack.size() != 1) {
+            throw new IllegalArgumentException("Invalid expression");
+        }
+
+        return stack.pop();
+    }
+
+    /**
+     * Checks if the given token is an operator.
+     *
+     * @param token The token to check.
+     * @return true if the token is an operator, false otherwise.
+     */
+    private static boolean isOperator(String token) {
+        return OPERATORS.contains(token);
+    }
+
+    /**
+     * Applies the given operator to the two operands.
+     *
+     * @param operator The operator to apply.
+     * @param a The first operand.
+     * @param b The second operand.
+     * @return The result of applying the operator to the operands.
+     */
+    private static int applyOperator(String operator, int a, int b) {
+        return switch (operator) {
+            case "+" -> a + b;
+            case "-" -> a - b;
+            case "*" -> a * b;
+            case "/" -> a / b;
+            default -> throw new IllegalArgumentException("Invalid operator");
+        };
+    }
+}