benchmarking bubble sort vs merge sort using JMH - algorithm

Question

I am benchmarking an implementation for merge sort and bubble sort for a school project using JMH.
The results aren't what I expected because it seems to me that bubble sort is performing better.
so is there something wrong in my benchmarking or my implementation of the algorithms?
benchmarking code:
#Benchmark
#BenchmarkMode(Mode.AverageTime)
#OutputTimeUnit(TimeUnit.NANOSECONDS)
#Fork(value = 1)
#Warmup(iterations = 2)
#Measurement(iterations = 3)
public void init() {
int arr[]={3,2,2,2,1,3,2,3,2,3,0,1,22,9,12,44,55,1000,99,33,333,4,33339,32,3,444,332345,32939,39493,3,2,2,2,1,3,2,3,2,3,0,1,22,9,12,44,55,1000,99,33,333,4,33339,32,3,444,332345,32939,39493,3,2,2,2,1,3,2,3,2,3,0,1,22,9,12,44,55,1000,99,33,333,4,33339,32,3,444,332345,32939,39493};
mergeSort(arr,0,arr.length-1);
//bubbleSort(arr);
}
The results:
merge sort:
"
# JMH version: 1.35
# VM version: JDK 16.0.2, Java HotSpot(TM) 64-Bit Server VM, 16.0.2+7-67
# VM invoker: C:\Program Files\Java\jdk-16.0.2\bin\java.exe
# VM options: -javaagent:C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2021.2.2\lib\idea_rt.jar=8379:C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2021.2.2\bin -Dfile.encoding=UTF-8
# Blackhole mode: full + dont-inline hint (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 2 iterations, 10 s each
# Measurement: 3 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: benchmark.testBM.init
# Run progress: 0.00% complete, ETA 00:00:50
# Fork: 1 of 1
# Warmup Iteration 1: 2411.561 ns/op
# Warmup Iteration 2: 2403.000 ns/op
Iteration 1: 2434.613 ns/op
Iteration 2: 2505.492 ns/op
Iteration 3: 2578.021 ns/op
Result "benchmark.testBM.init":
2506.042 ±(99.9%) 1308.179 ns/op [Average]
(min, avg, max) = (2434.613, 2506.042, 2578.021), stdev = 71.706
CI (99.9%): [1197.864, 3814.221] (assumes normal distribution)
# Run complete. Total time: 00:00:50
REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on
why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial
experiments, perform baseline and negative tests that provide experimental control, make sure
the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.
Do not assume the numbers tell you what you want them to tell.
Benchmark Mode Cnt Score Error Units
testBM.init avgt 3 2506.042 ± 1308.179 ns/op
Process finished with exit code 0
so its average is : 2506.042
bubble sort:
"
# Run progress: 0.00% complete, ETA 00:00:50
# Fork: 1 of 1
# Warmup Iteration 1: 1963.402 ns/op
# Warmup Iteration 2: 1815.476 ns/op
Iteration 1: 1831.914 ns/op
Iteration 2: 1863.120 ns/op
Iteration 3: 1874.605 ns/op
Result "benchmark.testBM.init":
1856.546 ±(99.9%) 403.037 ns/op [Average]
(min, avg, max) = (1831.914, 1856.546, 1874.605), stdev = 22.092
CI (99.9%): [1453.509, 2259.584] (assumes normal distribution)
# Run complete. Total time: 00:00:50
Benchmark Mode Cnt Score Error Units
testBM.init avgt 3 1856.546 ± 403.037 ns/op
Process finished with exit code 0
the average is : 1856.546
so does anyone know what is the problem may be?
implementation of bubble sort:
public int[] bubbleSort(int arr[])
{
for(int i = 0 ; i< arr.length;i++)
{
for(int j =arr.length-1 ; j>=i+1;j--)
{
if(arr[j]<arr[j-1])
{
int temp = arr[j-1];
arr[j-1]=arr[j];
arr[j]=temp;
}
}
}
return arr;
}
implementation of merge sort:
public void merge(int[] arr, int p, int q, int r) {
int left = q - p + 1;
int right = r - q;
int[] L = new int[left];
int[] R = new int[right];
for (int i = 0; i < left; ++i)
L[i] = arr[p + i];
for (int j = 0; j < right; ++j)
R[j] = arr[q + 1 + j];
int i = 0, j = 0;
int z = p;
while (i < left && j < right) {
if (L[i] <= R[j]) {
arr[z] = L[i];
i++;
} else {
arr[z] = R[j];
j++;
}
z++;
}
while (i < left) {
arr[z] = L[i];
i++;
z++;
}
while (j < right) {
arr[z] = R[j];
j++;
z++;
}
}
public void mergeSort(int[] arr, int p, int r) {
if (p < r) {
int q = p + (r - p) / 2;
mergeSort(arr, p, q);
mergeSort(arr, q + 1, r);
merge(arr, p, q, r);
}
}