https://github.com/vitaminvp/sorting-algorithms
Sorting Algorithms in JavaScript
https://github.com/vitaminvp/sorting-algorithms
bubble-sort counting-sort insertion-sort kottans merge-sort quick-sort selection-sort shell-sort sorting-algorithms
Last synced: 5 months ago
JSON representation
Sorting Algorithms in JavaScript
- Host: GitHub
- URL: https://github.com/vitaminvp/sorting-algorithms
- Owner: Vitaminvp
- Created: 2020-05-24T06:20:44.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2020-05-27T21:22:27.000Z (over 5 years ago)
- Last Synced: 2025-04-11T22:53:31.410Z (8 months ago)
- Topics: bubble-sort, counting-sort, insertion-sort, kottans, merge-sort, quick-sort, selection-sort, shell-sort, sorting-algorithms
- Language: JavaScript
- Size: 46.5 MB
- Stars: 3
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Sorting-Algorithms
Sorting Algorithms in JavaScript
+ [Bubble sort](#bubbleSort)
+ [Selection Sort](#selectionSort)
+ [Insertion Sort](#insertionSort)
+ [Merge Sort](#mergeSort)
+ [Quick Sort](#quickSort)
+ [Shell Sort](#shellSort)
+ [Counting Sort](#сountingSort)
+ [Comb Sort](#combSort)
## Bubble sort
Первый метод сортировки называется пузырьковой сортировкой ***Bubble sort***, в рамках которой выполняются следующие действия:
проход по файлу с обменом местами соседних элементов, нарушающих заданный порядок, до тех пор, пока файл не будет окончательно отсортирован.
Основное достоинство пузырьковой сортировки заключается в том, что его легко реализовать в виде программы.
Для понимания и реализации этот алгоритм — простейший, но эффективен он лишь для небольших массивов.
Суть алгоритма пузырьковой сортировки состоит в сравнении соседних элементов и их обмене, если они находятся не в надлежащем порядке.
Неоднократно выполняя это действие, мы заставляем наибольший элемент "всплывать" к концу массива.
Следующий проход приведет к всплыванию второго наибольшего элемента, и так до тех пор, пока после *n-1* итерации массив не будет полностью отсортирован.
> Сложность алгоритма: O(n2).
[wiki](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%BC "Bubble sort animation")
## Selection Sort
Сортировка выбором ***Selection Sort*** начинается с поиска наименьшего элемента в списке и обмена его с первым элементом
(таким образом, наименьший элемент помещается в окончательную позицию в отсортированном массиве).
Затем мы сканируем массив, начиная со второго элемента, в поисках наименьшего среди оставшихся *n-1* элементов и обмениваем найденный наименьший элемент со вторым,
т.е. помещаем второй наименьший элемент в окончательную позицию в отсортированном массиве.
В общем случае, при i-ом проходе по списку *(0 ≤ i ≤ n-2)* алгоритм ищет наименьший элемент среди последних *n-i* элементов и обменивает его с *A[ i ]*.
После выполнения *n-1* проходов список оказывается отсортирован.
> Сложность алгоритма: O(n2).
[wiki](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BE%D0%BC
"Selection sort")
## Insertion Sort
На каждом шаге алгоритма сортировки встаками выбирается один из элементов входного массива и вставляется на нужную позицию в уже отсортированном массиве,
до тех пор, пока входных элементы не будут исчерпана.
Метод выбора очередного элемента из исходного массива произволен; может использоваться практически любой алгоритм выбора.
Обычно (и с целью получения устойчивого алгоритма сортировки), элементы вставляются по порядку их появления во входном массиве.
В приведённой ниже реализации на JavaScript алгоритма сортировки встаками используется именно эта стратегия выбора.
> Сложность алгоритма: O(n2).
[wiki](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%B2%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%D0%BC%D0%B8
"Selection sort")
## Merge Sort
Сортировка слиянием использует подход «разделяй и властвуй» для сортировки элементов в массиве.
По сути, это означает, что вместо работы с массивом в целом он непрерывно разбивает его на две части,
пока обе половины не отсортированы, а затем половины объединяются в один решенный список.
> Сложность алгоритма: O(n log n).
[wiki](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D1%81%D0%BB%D0%B8%D1%8F%D0%BD%D0%B8%D0%B5%D0%BC
"Merge sort")
## Quick Sort
> Сложность алгоритма: O(n2).
[wiki](https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0 "Quick sort")
## Shell Sort
Shell Sort «сортировкой по убыванию», улучшает Insertion Sort,
разбивая исходный массив на несколько меньших подмассивов, каждый из которых сортируется с использованием Insertion Sort.
Способ выбора этих подмассивов - уникальность Shell Sort. Вместо того, чтобы разбивать массив на подмассивы смежных элементов,
сортировка оболочки использует интервал *d*, иногда называемый *gap*, для создания подмассива, выбирая все элементы,
которые являются d-ми элементами, отдельно.
+ Самый простой пример *d = n / 2*, *d2 = d / 2 … dn = 1*. ***O(n2)***
+ Предложение Хиббарда: проверить на всем ni — 1 <= n. ***O(n3/2)***
+ Числа Седжвика ...
> Сложность алгоритма: O(n2) или O(n3/2).
[](https://www.youtube.com/watch?v=lvts84Qfo8o)
## Counting Sort
Вначале для каждого элемента массива подсчитывается количество элементов, меньших, чем он, и на основе этой
информации текущий элемент помещается в соответствующее место отсортированного массива.
> Сложность алгоритма: O(n2).
## Comb Sort
Сортировка расчёской схожа с сортировкой пузырьком.
Основная идея этого алгоритма — устранить маленькие значения в конце массива, которые крайне замедляют сортировку пузырьком
(большие значения в начале массива, не представляют проблемы для алгоритма сортировки пузырьком).
В сортировке пузырьком, когда сравниваются два элемента, промежуток (расстояние друг от друга) равен 1.
Основная идея сортировки расчёской в том, что этот промежуток может быть гораздо больше, чем единица.
> Сложность алгоритма: O(n2).
