Benchmark: SortingTests - MeasureThat.net

Script Preparation code:

const max =100;
const type = 0;
 unsorted= [];
const sample = 1100000000;
while (unsorted.length < max) {
	const count = unsorted.length;
	let t = 0;
	if(type === 0) {
		t = Math.floor(Math.random() * (sample*2)) + sample;
	} else if(type === 1) {
		t = sample  + (count*1000);
	} else if(type === 2) {
		t = sample  - (count*1000);
	}
	if(unsorted.findIndex(it => it.timestamp === t) === -1) {
		 unsorted.push({
         proceedingTime: 20,
         maxWaitingTime: 'asjdsjadsajdjsadadasd',
         maxWaitingTimeEnabled: true,
         alertWaitingDelay: 60,
         maintainPositionTime: '2387423784723847823487',
         maintainWaitingPosition: true,
         timestamp: t
      });
   }
}

function builtin_sort(unsorted) {
  return unsorted.sort((a, b) => {
    return a.timestamp - b.timestamp;
  });
}

function naive_quicksort(ary) {
  if (ary.length <= 1) {
    return ary;
  }
  var less = [],
    greater = [],
    pivot = ary.pop();
  for (var i = 0; i < ary.length; i++) {
    if (ary[i].timestamp < pivot.timestamp) {
      less.push(ary[i]);
    } else {
      greater.push(ary[i]);
    }
  }
  less = naive_quicksort(less);
  greater = naive_quicksort(greater);
  return less.concat(pivot, greater);
}

function insertion_sort(ary) {
  for (var i = 1, l = ary.length; i < l; i++) {
    var value = ary[i];
    for (var j = i - 1; j >= 0; j--) {
      if (ary[j].timestamp <= value.timestamp)
        break;
      ary[j + 1] = ary[j];
    }
    ary[j + 1] = value;
  }
  return ary;
}

function shell_sort(ary) {
  var inc = Math.round(ary.length / 2),
    i, j, t;
  while (inc > 0) {
    for (i = inc; i < ary.length; i++) {
      t = ary[i];
      j = i;
      while (j >= inc && ary[j - inc].timestamp > t.timestamp) {
        ary[j] = ary[j - inc];
        j -= inc;
      }
      ary[j] = t;
    }
    inc = Math.round(inc / 2.2);
  }
  return ary;
}

function inplace_quicksort_partition(ary, start, end, pivotIndex) {
  var i = start, j = end;
  var pivot = ary[pivotIndex];
  while (true) {
    while (ary[i].timestamp < pivot.timestamp) { i++ };
    j--;
    while (pivot.timestamp < ary[j].timestamp) { j-- };
    if (!(i < j)) {
      return i;
    }
    swap(ary, i, j);
    i++;
  }
}

function inplace_quicksort(ary, start, end) {
  if (start < end - 1) {
    var pivotIndex = Math.round((start + end) / 2);
    pivotIndex = inplace_quicksort_partition(ary, start, end, pivotIndex);
    inplace_quicksort(ary, start, pivotIndex - 1);
    inplace_quicksort(ary, pivotIndex + 1, end);
  }
  return ary;
}

function fast_quicksort(ary) {
  var stack = [];
  var entry = [0, ary.length, 2 * Math.floor(Math.log(ary.length) / Math.log(2))];
  stack.push(entry);
  while (stack.length > 0) {
    entry = stack.pop();
    var start = entry[0];
    var end = entry[1];
    var depth = entry[2];
    if (depth == 0) {
      ary = shell_sort_bound(ary, start, end);
      continue;
    }
    depth--;
    var pivot = Math.round((start + end) / 2);
    var pivotNewIndex = inplace_quicksort_partition(ary, start, end, pivot);
    if (end - pivotNewIndex > 16) {
      entry = [pivotNewIndex, end, depth];
      stack.push(entry);
    }
    if (pivotNewIndex - start > 16) {
      entry = [start, pivotNewIndex, depth];
      stack.push(entry);
    }
  }
  ary = insertion_sort(ary);
  return ary;
}

function shell_sort_bound(ary, start, end) {
  var inc = Math.round((start + end) / 2),
    i, j, t;
  while (inc >= start) {
    for (i = inc; i < end; i++) {
      t = ary[i];
      j = i;
      while (j >= inc && ary[j - inc].timestamp > t.timestamp) {
        ary[j] = ary[j - inc];
        j -= inc;
      }
      ary[j] = t;
    }
    inc = Math.round(inc / 2.2);
  }
  return ary;
}

function swap(ary, a, b) {
  var t = ary[a];
  ary[a] = ary[b];
  ary[b] = t;
}

Tests:

builtin_sort
const sorted = builtin_sort(unsorted.slice());
insertion_sort
const sorted = insertion_sort(unsorted.slice());
shell_sort
const sorted = shell_sort(unsorted.slice());
inplace_quicksort
const un = unsorted.slice(); const sorted = inplace_quicksort(un, 0, un.length-1);
fast_quicksort
const sorted = fast_quicksort(unsorted.slice());

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
builtin_sort
insertion_sort
shell_sort
inplace_quicksort
fast_quicksort

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0

Browser/OS: Chrome 132 on Windows

View result in a separate tab

fast_quicksort

312K/s

inplace_quicksort

259K/s

shell_sort

133K/s

insertion_sort

87K/s

builtin_sort

52K/s

View exact numbers

Test name	Executions per second
✓ fast_quicksort	311,794 Ops/sec
inplace_quicksort	258,622 Ops/sec
shell_sort	133,051 Ops/sec
insertion_sort	87,290 Ops/sec
builtin_sort	52,254 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Based on the provided benchmark results, I'll provide an analysis and comparison of the sorting algorithms.

**Benchmark Results Analysis**

The benchmark results show the execution time per second for each sorting algorithm:

1. **shell_sort**: 218.4ms ( Chrome 96)
2. **insertion_sort**: 210.2ms (Chrome 96)
3. **builtin_sort**: 118.1ms (Chrome 96)
4. **fast_quicksort**: 75.3ms (Chrome 96)
5. **inplace_quicksort**: 32.6ms (Chrome 96)

**Comparison**

* **shell_sort** and **insertion_sort** are relatively close in execution time, with shell_sort being slightly faster.
* **builtin_sort** is the fastest among all five algorithms.
* **fast_quicksort** is also fast, but slower than **builtin_sort**.
* **inplace_quicksort** has the shortest execution time, making it the fastest algorithm.

**Conclusion**

Based on the benchmark results, **inplace_quicksort** is the fastest sorting algorithm among the five options. However, the performance difference between algorithms can vary depending on the specific use case and input data. It's essential to consider factors like code complexity, memory usage, and edge cases when choosing a sorting algorithm.

For reference, here are some general guidelines:

* **Small datasets**: Inplace_quicksort or insertion_sort might be suitable choices.
* **Large datasets**: Shell sort or fast_quicksort could be more efficient.
* **Performance-critical applications**: Benchmarking individual algorithms is crucial to determine the best approach for a specific use case.

SortingTests (version: 7)

Comparing performance of: `builtin_sort vs insertion_sort vs shell_sort vs inplace_quicksort vs fast_quicksort`

Created: 4 years ago by: Registered User

Go to the latest result

builtin_sort

insertion_sort

shell_sort

inplace_quicksort

fast_quicksort

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

SortingTests (version: 7)

Comparing performance of: builtin_sort vs insertion_sort vs shell_sort vs inplace_quicksort vs fast_quicksort

Created: 4 years ago by: Registered User

Go to the latest result

builtin_sort

insertion_sort

shell_sort

inplace_quicksort

fast_quicksort

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

Related benchmarks

Comparing performance of: `builtin_sort vs insertion_sort vs shell_sort vs inplace_quicksort vs fast_quicksort`