Benchmarking Algorithms with TheAlgorithms Java Harness

To get a quick timing measurement for any algorithm in the TheAlgorithms/Java repository, run the built‑in harness from the command line:

java -cp target/classes com.thealgorithms.Main AlgorithmClass arraySize [repetitions]

Replace AlgorithmClass with the fully‑qualified name of the class that implements the Algorithm interface (e.g., Sorting.quickSort), arraySize with the length of the random integer array you want to test, and optionally repetitions with how many times the algorithm should be executed for averaging.

How the harness works

The entry point is the Main class (com.thealgorithms.Main). Its public static void main(String[] args) method:

1. Parses the first argument as the algorithm name.
2. Uses Java reflection to locate the class implementing com.thealgorithms.interfaces.Algorithm in the com.thealgorithms package.
3. Instantiates that class and prepares a random int[] of the requested size.
4. For each repetition (default 1) it:
1. Records System.nanoTime().
2. Calls algorithm.execute(input).
3. Records the end time and accumulates the elapsed nanoseconds.
4. After the run, checks correctness by comparing the result with Arrays.sort on a copy of the original array.
5. Finally prints the average runtime in milliseconds and a “PASS/FAIL” correctness message.

Worked example

Assuming you have cloned the repository and compiled it with Maven:

# From the repository root
mvn clean compile
# Run QuickSort on 10 000 integers, averaged over 5 runs
java -cp target/classes com.thealgorithms.Main Sorting.quickSort 10000 5

The command will output something like:

Average time: 2.34 ms
Result: PASS

(Exact numbers will vary; the harness does not guarantee any specific value.)

Limits of the harness

• Interface constraint: Only classes that implement the single‑method Algorithm.execute(int[]) interface can be benchmarked directly. Algorithms that need extra parameters (e.g., graph algorithms requiring an adjacency list) must be wrapped or are excluded.
• JVM warm‑up and GC: The timing includes class loading, JIT compilation, and garbage‑collection overhead. For very small input sizes the measured time may be dominated by these effects rather than the algorithm’s intrinsic cost.
• Single‑threaded: The harness runs sequentially; concurrent execution from multiple threads is not supported and may produce incorrect results due to shared mutable state.

Common mistakes and how to avoid them

• Missing classpath: If target/classes is not on the classpath, you will see ClassNotFoundException. Always include -cp target/classes (or the equivalent Maven exec:java plugin).
• Incorrect algorithm name: The name must match the exact fully‑qualified class name, case‑sensitive. A typo leads to a reflection error like NoSuchMethodException or InvocationTargetException.
• Reusing mutable input: The harness creates a fresh random array for each repetition, but if you modify the harness to reuse the same array, the array will be sorted after the first run, causing artificially low times. Keep the input generation inside the timing loop or reset the array before each iteration.

Practical verification steps

1. Clone the repository: git clone https://github.com/TheAlgorithms/Java.git
2. Check out the latest main branch and build: mvn clean compile
3. Run a known algorithm, for example merge sort on 5 000 elements with three repetitions:

java -cp target/classes com.thealgorithms.Main Sorting.mergeSort 5000 3

4. Observe the printed average time and a “PASS” correctness line.
5. Vary the arraySize or repetitions and confirm that the reported time changes in a predictable direction (larger size → higher time, more repetitions → similar average but tighter confidence).
6. Supply a non‑existent algorithm name (e.g., java -cp target/classes com.thealgorithms.Main NonExistent.Algo 1000 1) and verify that the harness prints a clear error message about class not found.