comb Sort Algorithm
Comb Sort is a comparison-based sorting algorithm that is an improvement over the traditional Bubble Sort algorithm. It was devised by Włodzimierz Dobosiewicz and Artur Borowy in 1980 and later rediscovered by Stephen Lacey and Richard Box in 1991. Unlike Bubble Sort, which compares and swaps adjacent elements, Comb Sort compares elements that are a specific gap apart, where the gap is successively reduced in each iteration. The idea behind using a gap is to eliminate smaller elements that are far away from their correct positions, known as "turtles," which slow down Bubble Sort. The algorithm continues to shrink the gap and perform comparisons until the gap becomes one, and the list is fully sorted.
Initially, the gap is set to a large value, typically the total number of elements in the list divided by a "shrink factor," which is usually 1.3. In each iteration, the algorithm compares elements that are "gap" distance apart and swaps them if they are in the wrong order. After processing the entire list, the gap is reduced by dividing it by the shrink factor, and the process is repeated. This continues until the gap becomes one, at which point the algorithm behaves like a regular Bubble Sort. However, by that time, the list is partially sorted, and the remaining comparisons and swaps are minimal. Comb Sort's performance is significantly better than Bubble Sort, with an average-case time complexity of O(n^2/2^p), where p is the number of increments, and a best-case time complexity of O(n log n) if the list is already partially sorted.
/*
Wikipedia says: Comb sort improves on bubble sort.
The basic idea is to eliminate turtles, or small values
near the end of the list, since in a bubble sort these slow the sorting
down tremendously. Rabbits, large values around the beginning of the list,
do not pose a problem in bubble sort.
In bubble sort, when any two elements are compared, they always have a
gap (distance from each other) of 1. The basic idea of comb sort is
that the gap can be much more than 1. The inner loop of bubble sort,
which does the actual swap, is modified such that gap between swapped
elements goes down (for each iteration of outer loop) in steps of
a "shrink factor" k: [ n/k, n/k2, n/k3, ..., 1 ].
*/
function combSort (list) {
if (list.length === 0) {
return list
}
const shrink = 1.3
let gap = list.length
let isSwapped = true
let i = 0
while (gap > 1 || isSwapped) {
// Update the gap value for a next comb
gap = parseInt(parseFloat(gap) / shrink, 10)
isSwapped = false
i = 0
while (gap + i < list.length) {
if (list[i] > list[i + gap]) {
[list[i], list[i + gap]] = [list[i + gap], list[i]]
isSwapped = true
}
i += 1
}
}
return list
}
const arrOrignal = [5, 6, 7, 8, 1, 2, 12, 14]
// Array before Sort
console.log(arrOrignal)
const arrSorted = combSort(arrOrignal)
// Array after sort
console.log(arrSorted)
