Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/conversion/HexStringConverter.java

@@ -0,0 +1,110 @@
+package com.baeldung.algorithms.conversion;
+
+import java.math.BigInteger;
+
+import javax.xml.bind.DatatypeConverter;
+
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
+
+import com.google.common.io.BaseEncoding;
+
+public class HexStringConverter {
+
+    /**
+     * Create a byte Array from String of hexadecimal digits using Character conversion 
+     * @param hexString - Hexadecimal digits as String
+     * @return Desired byte Array
+     */
+    public byte[] decodeHexString(String hexString) {
+        if (hexString.length() % 2 == 1) {
+            throw new IllegalArgumentException("Invalid hexadecimal String supplied.");
+        }
+        byte[] bytes = new byte[hexString.length() / 2];
+
+        for (int i = 0; i < hexString.length(); i += 2) {
+            bytes[i / 2] = hexToByte(hexString.substring(i, i + 2));
+        }
+        return bytes;
+    }
+
+    /**
+     * Create a String of hexadecimal digits from a byte Array using Character conversion
+     * @param byteArray - The byte Array
+     * @return Desired String of hexadecimal digits in lower case
+     */
+    public String encodeHexString(byte[] byteArray) {
+        StringBuffer hexStringBuffer = new StringBuffer();
+        for (int i = 0; i < byteArray.length; i++) {
+            hexStringBuffer.append(byteToHex(byteArray[i]));
+        }
+        return hexStringBuffer.toString();
+    }
+
+    public String byteToHex(byte num) {
+        char[] hexDigits = new char[2];
+        hexDigits[0] = Character.forDigit((num >> 4) & 0xF, 16);
+        hexDigits[1] = Character.forDigit((num & 0xF), 16);
+        return new String(hexDigits);
+    }
+
+    public byte hexToByte(String hexString) {
+        int firstDigit = toDigit(hexString.charAt(0));
+        int secondDigit = toDigit(hexString.charAt(1));
+        return (byte) ((firstDigit << 4) + secondDigit);
+    }
+
+    private int toDigit(char hexChar) {
+        int digit = Character.digit(hexChar, 16);
+        if(digit == -1) {
+            throw new IllegalArgumentException("Invalid Hexadecimal Character: "+ hexChar);
+        }
+        return digit;
+    }
+
+    public String encodeUsingBigIntegerToString(byte[] bytes) {
+        BigInteger bigInteger = new BigInteger(1, bytes);
+        return bigInteger.toString(16);
+    }
+
+    public String encodeUsingBigIntegerStringFormat(byte[] bytes) {
+        BigInteger bigInteger = new BigInteger(1, bytes);
+        return String.format("%0" + (bytes.length << 1) + "x", bigInteger);
+    }
+
+    public byte[] decodeUsingBigInteger(String hexString) {
+        byte[] byteArray = new BigInteger(hexString, 16).toByteArray();
+        if (byteArray[0] == 0) {
+            byte[] output = new byte[byteArray.length - 1];
+            System.arraycopy(byteArray, 1, output, 0, output.length);
+            return output;
+        }
+        return byteArray;
+    }
+
+    public String encodeUsingDataTypeConverter(byte[] bytes) {
+        return DatatypeConverter.printHexBinary(bytes);
+    }
+
+    public byte[] decodeUsingDataTypeConverter(String hexString) {
+        return DatatypeConverter.parseHexBinary(hexString);
+    }
+
+    public String encodeUsingApacheCommons(byte[] bytes) throws DecoderException {
+        return Hex.encodeHexString(bytes);
+    }
+
+    public byte[] decodeUsingApacheCommons(String hexString) throws DecoderException {
+        return Hex.decodeHex(hexString);
+    }
+
+    public String encodeUsingGuava(byte[] bytes) {
+        return BaseEncoding.base16()
+            .encode(bytes);
+    }
+
+    public byte[] decodeUsingGuava(String hexString) {
+        return BaseEncoding.base16()
+            .decode(hexString.toUpperCase());
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/knapsack/Knapsack.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.knapsack;
+
+public class Knapsack {
+
+    public int knapsackRec(int[] w, int[] v, int n, int W) {
+        if (n <= 0) {
+            return 0;
+        } else if (w[n - 1] > W) {
+            return knapsackRec(w, v, n - 1, W);
+        } else {
+            return Math.max(knapsackRec(w, v, n - 1, W), v[n - 1] + knapsackRec(w, v, n - 1, W - w[n - 1]));
+        }
+    }
+
+    public int knapsackDP(int[] w, int[] v, int n, int W) {
+        if (n <= 0 || W <= 0) {
+            return 0;
+        }
+
+        int[][] m = new int[n + 1][W + 1];
+        for (int j = 0; j <= W; j++) {
+            m[0][j] = 0;
+        }
+
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= W; j++) {
+                if (w[i - 1] > j) {
+                    m[i][j] = m[i - 1][j];
+                } else {
+                    m[i][j] = Math.max(m[i - 1][j], m[i - 1][j - w[i - 1]] + v[i - 1]);
+                }
+            }
+        }
+        return m[n][W];
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/relativelyprime/RelativelyPrime.java

@@ -0,0 +1,45 @@
+package com.baeldung.algorithms.relativelyprime;
+
+import java.math.BigInteger;
+
+class RelativelyPrime {
+
+    static boolean iterativeRelativelyPrime(int a, int b) {
+        return iterativeGCD(a, b) == 1;
+    }
+
+    static boolean recursiveRelativelyPrime(int a, int b) {
+        return recursiveGCD(a, b) == 1;
+    }
+
+    static boolean bigIntegerRelativelyPrime(int a, int b) {
+        return BigInteger.valueOf(a).gcd(BigInteger.valueOf(b)).equals(BigInteger.ONE);
+    }
+
+    private static int iterativeGCD(int a, int b) {
+        int tmp;
+        while (b != 0) {
+            if (a < b) {
+                tmp = a;
+                a = b;
+                b = tmp;
+            }
+            tmp = b;
+            b = a % b;
+            a = tmp;
+        }
+        return a;
+    }
+
+    private static int recursiveGCD(int a, int b) {
+        if (b == 0) {
+            return a;
+        }
+        if (a < b) {
+            return recursiveGCD(b, a);
+        }
+        return recursiveGCD(b, a % b);
+    }
+
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/reversingtree/TreeNode.java

@@ -0,0 +1,42 @@
+package com.baeldung.algorithms.reversingtree;
+
+public class TreeNode {
+
+    private int value;
+    private TreeNode rightChild;
+    private TreeNode leftChild;
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+
+    public TreeNode getRightChild() {
+        return rightChild;
+    }
+
+    public void setRightChild(TreeNode rightChild) {
+        this.rightChild = rightChild;
+    }
+
+    public TreeNode getLeftChild() {
+        return leftChild;
+    }
+
+    public void setLeftChild(TreeNode leftChild) {
+        this.leftChild = leftChild;
+    }
+
+    public TreeNode(int value, TreeNode leftChild, TreeNode rightChild) {
+        this.value = value;
+        this.rightChild = rightChild;
+        this.leftChild = leftChild;
+    }
+
+    public TreeNode(int value) {
+        this.value = value;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/reversingtree/TreeReverser.java

@@ -0,0 +1,53 @@
+package com.baeldung.algorithms.reversingtree;
+
+import java.util.LinkedList;
+
+public class TreeReverser {
+
+    public void reverseRecursive(TreeNode treeNode) {
+        if (treeNode == null) {
+            return;
+        }
+
+        TreeNode temp = treeNode.getLeftChild();
+        treeNode.setLeftChild(treeNode.getRightChild());
+        treeNode.setRightChild(temp);
+
+        reverseRecursive(treeNode.getLeftChild());
+        reverseRecursive(treeNode.getRightChild());
+    }
+
+    public void reverseIterative(TreeNode treeNode) {
+        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
+
+        if (treeNode != null) {
+            queue.add(treeNode);
+        }
+
+        while (!queue.isEmpty()) {
+
+            TreeNode node = queue.poll();
+            if (node.getLeftChild() != null)
+                queue.add(node.getLeftChild());
+            if (node.getRightChild() != null)
+                queue.add(node.getRightChild());
+
+            TreeNode temp = node.getLeftChild();
+            node.setLeftChild(node.getRightChild());
+            node.setRightChild(temp);
+        }
+    }
+
+    public String toString(TreeNode root) {
+        if (root == null) {
+            return "";
+        }
+
+        StringBuffer buffer = new StringBuffer(String.valueOf(root.getValue())).append(" ");
+
+        buffer.append(toString(root.getLeftChild()));
+        buffer.append(toString(root.getRightChild()));
+
+        return buffer.toString();
+    }
+}

algorithms-miscellaneous-5/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>