Алгоритм швидкого сортування в JavaСкрипт із прикладом
⚡ Розумний підсумок
Алгоритм швидкого сортування в JavaСкрипт сортує масив на місці, вибираючи опорну точку, розділяючи менші значення ліворуч і більші значення праворуч, а потім рекурсивно. Він усереднює O(n log n) і перевершує вбудовану sort() на великих числових наборах даних.

Що таке швидке сортування?
Швидке сортування — це алгоритм сортування порівнянням, який дотримується Розділяй і володарюй підхід. Він вибирає один елемент як опорну точку, розбиває масив на частину, яка містить значення, менші за опорну точку, і частину, яка містить більші значення, а потім застосовує ту саму процедуру до кожної частини, доки весь масив не буде впорядковано.
Швидке сортування – один із найпоширеніших алгоритмів сортування в кожній мові програмування. Якщо ви пишете JavaScript, ви, ймовірно, вже використовували вбудований сортувати () метод, тому ви можете задатися питанням, чому варто вивчати окрему реалізацію швидкого сортування. Щоб відповісти на це питання, вам спочатку потрібно знати, що означає сортування та що таке сортування за замовчуванням у JavaСценарій насправді так і робить.
Три властивості визначають швидке сортування:
- На місці: він переставляє оригінал масив і не виділяє другий масив такого ж розміру.
- Рекурсивний: кожен розділ створює два менші діапазони, які сортуються за допомогою однієї й тієї ж функції.
- Нестабільний: Два елементи з однаковими ключами можуть опинитися в іншому відносному порядку, ніж той, у якому вони починали.
Що таке сортування?
Сортування означає розташування елементів у визначеному порядку. Ви майже напевно зустрічали це в школі: розстановка чисел від найменшого до найбільшого є висхідний порядок, а розташування їх від найбільшого до найменшого є спускається порядок. Сортування не обмежується числами. Рядки можна впорядкувати в алфавітному порядку, дати – в хронологічному порядку, а об’єкти – за будь-яким вибраним полем, наприклад, ціною чи балом.
Сортування має значення, оскільки впорядковані дані розблоковують швидші операції. Бінарний пошук виконується за час O(log n), але лише на відсортованих вхідних даних. Дедуплікація, діапазонні запити, ранжування та операції злиття стають набагато дешевшими, коли дані впорядковані, тому кожна мова програмування постачає принаймні одну процедуру сортування.
Сортування за замовчуванням у JavaScript
Як згадувалося раніше, JavaСценарій надає сортувати ()Візьмемо невеликий масив, наприклад [5,3,7,6,2,9], який потрібно розташувати у порядку зростання. Виклик сортувати () на масиві, здається, робить саме це.
На скріншоті вище показано, як консоль браузера виводить відсортований масив. Ось той самий код:
var items = [5, 3, 7, 6, 2, 9]; console.log(items.sort());
вихід:
[ 2, 3, 5, 6, 7, 9 ]
Цей результат правильний, але лише випадково. Array.prototype.sort() перетворює кожен елемент на рядок та порівнює рядки якщо ви не надасте функцію порівняння. Кожне значення в цьому масиві є одноцифровим, тому порядок рядків збігається з числовим порядком. Змініть дані, і ілюзія зникне.
var prices = [10, 9, 1, 100, 25]; console.log(prices.sort()); // string comparison console.log(prices.sort(function (a, b) { return a - b; })); // numeric comparison
вихід:
[ 1, 10, 100, 25, 9 ] [ 1, 9, 10, 25, 100 ]
⚠️ Попередження: Ніколи не дзвони sort() для чисел без компаратора. «100» сортується раніше за «25», оскільки символ «1» стоїть перед символом «2». Завжди пишіть sort((a, b) => a - b) для числових даних.
Який алгоритм використовує sort()?
У специфікації не вказано алгоритм, тому кожен рушій обирає свій власний. Сучасні рушії використовують алгоритм на основі злиття:
- V8 (Chrome, Edge, Node.js) використовував TimSort починаючи з V8 7.0, постачається в Chrome 70.
- Павук -Мавпа (Firefox) використовує сортування злиттям.
- JavaScriptCore (Safari) також використовує сортування злиттям.
Починаючи з ES2019, мова гарантує, що sort() is стабільний, що виключає просте швидке сортування всередині механізму. Сортування на основі злиття потребує O(n) допоміжної пам'яті, і воно повинно викликати вашу JavaСкриптовий компаратор для кожного окремого порівняння. Рукописна числова швидка сортування порівнює числа безпосередньо та сортує на місці, тому вона може вигравати на великих числових масивах. Сортування 1 000 000 випадкових цілих чисел на Node.js 22 зайняло приблизно 100 мс за допомогою швидкого сортування нижче та приблизно 210 мс з sort((a, b) => a - b).
Отже, про швидке сортування варто писати, коли вам потрібне сортування на місці, чіткий контроль над пам'яттю або просто чітке розуміння того, як працює сортування. Давайте детально розглянемо механіку.
Як працює швидке сортування?
Швидке сортування повторює одну основну операцію, яка називається перегородка, на все менших і менших діапазонах. Ось кроки в такому порядку:
- Знайти стрижень елемент у масиві.
- Почніть лівий вказівник з першого елемента діапазону.
- Почніть правий вказівник з останнього елемента діапазону.
- Порівняйте елемент у лівому вказівнику з точкою опори. Якщо він менший за точку опори, перемістіть лівий вказівник на один крок праворуч. Продовжуйте, доки лівий елемент не стане більшим або дорівнюватиме точці опори.
- Порівняйте елемент у правому вказівнику з точкою опори. Якщо він більший за точку опори, перемістіть правий вказівник на один крок ліворуч. Продовжуйте, доки правий елемент не стане меншим або рівним точці опори.
- Якщо лівий вказівник все ще менший або дорівнює правому вказівнику, поміняйте місцями два елементи.
- Збільшити лівий покажчик і зменшити правий.
- Якщо лівий індекс все ще менший або дорівнює правому індексу, повторіть дії з кроку 4. В іншому випадку поверніть індекс лівого вказівника.
Діаграма вище tracці рухи вказівника на зразку масиву. Кожен елемент, менший за опорну точку, опиняється ліворуч від неї, а кожен більший елемент – праворуч від неї, що саме і є позначкою повернутого індексу. У розділі нижче крок за кроком розглядається той самий масив.
Як визначити опорний елемент
Вибір опорної точки — це єдине рішення, яке відрізняє швидке сортування від повільного. Якщо ви завжди використовуєте перший елемент, вже відсортований масив створює найгірший можливий розкол: одна порожня сторона та одна сторона з кожним елементом, що залишився. Це перетворює алгоритм на O(n²). Беручи середній елемент (довжина масиву, поділена на два) дозволяє уникнути цієї пастки для відсортованих та зворотно відсортованих вхідних даних, тому код нижче його використовує.
Поширені стратегії повороту:
- Перший або останній елемент: найпростіше кодувати, але O(n²) для відсортованих даних.
- Середній елемент: гарний параметр за замовчуванням, який обробляє відсортовані та зворотно відсортовані масиви за O(n log n).
- Випадковий елемент: унеможливлює побудову вхідних даних для найгіршого випадку заздалегідь.
- Медіана з трьох: бере медіану першого, середнього та останнього значень; стандартний вибір у виробничих бібліотеках.
Тепер пройдіться швидким сортуванням масиву [5,3,7,6,2,9].
КРОК 1: Опорна точка – це середній елемент. Якщо ліворуч = 0, а праворуч = 5, Math.floor((5 + 0) / 2) дає індекс 2, тому значення опорної точки дорівнює 7.
КРОК 2: Починайте вказівники з кінців масиву. Лівий вказівник має індекс 0 (значення 5) а правий вказівник знаходиться на індексі 5 (значення 9).
КРОК 3: Порівняйте ліве значення зі значенням точки опори. 5 < 7, тому перемістіться праворуч до індексу 1. 3 < 7, тому перемістіться праворуч до індексу 2. Значення там дорівнює 7, що не менше за значення точки опори, тому лівий вказівник зупиняється на індексі 2.
КРОК 4: Порівняйте праве значення з точкою опори. 9 > 7, тому перемістіться ліворуч до індексу 4. Значення там дорівнює 2, що не більше за точку опори, тому правий вказівник зупиняється на індексі 4.
КРОК 5: Лівий індекс (2) менший або дорівнює правому індексу (4), тому поміняйте місцями два значення. Масив стає [5,3,2,6,7,9].
КРОК 6: Перемістіть обидва вказівники на один крок всередину. Лівий вказівник тепер знаходиться на індексі 3, а правий — на індексі 3.
КРОК 7: Повторіть сканування. Значення за індексом 3 дорівнює 6, а 6 < 7, тому лівий вказівник переміщується до індексу 4. Значення за індексом 3 не більше, ніж точка опори, тому правий вказівник залишається на індексі 3.
КРОК 8: Лівий індекс (4) тепер більший за правий індекс (3), тому цикл завершується, і функція повертає значення 4Все перед індексом 4 менше або дорівнює опорній точці, а все, починаючи з індексу 4, більше або дорівнює їй.
Виходячи з цього покрокового керівництва, вам потрібен код для двох операцій: swapping два елементи та розбиття діапазону.
Code обмінятися двома Numbers in JavaScript
Як показано на скріншоті редактора вище, допоміжний метод swap використовує тимчасову змінну для обміну значеннями за двома індексами. Він безпосередньо змінює масив і нічого не повертає.
function swap(items, leftIndex, rightIndex) { var temp = items[leftIndex]; items[leftIndex] = items[rightIndex]; items[rightIndex] = temp; } var demo = [5, 3, 7, 6, 2, 9]; swap(demo, 0, 5); console.log(demo);
вихід:
[ 9, 3, 7, 6, 2, 5 ]
💡 Порада: Modern JavaСкрипт може замінюватися без тимчасової змінної, використовуючи деструктуризацію масиву: [items[i], items[j]] = [items[j], items[i]];Він читається чіткіше, хоча явний помічник трохи швидший у гарячих циклах, оскільки уникає виділення тимчасового масиву.
Code виконати розділення
Код на скріншоті вище перетворює кроки з 1 по 8 на функцію. Два внутрішні петлі просунути вказівники, if Блок виконує заміну, а функція повертає індекс поділу.
function partition(items, left, right) { var pivot = items[Math.floor((right + left) / 2)], // middle element i = left, // left pointer j = right; // right pointer while (i <= j) { while (items[i] < pivot) { i++; } while (items[j] > pivot) { j--; } if (i <= j) { swap(items, i, j); // swap two elements i++; j--; } } return i; } var items = [5, 3, 7, 6, 2, 9]; var index = partition(items, 0, items.length - 1); console.log(items); console.log(index);
вихід:
[ 5, 3, 2, 6, 7, 9 ] 4
Вивід точно відповідає покроковому посібнику: після одного проходу розділення масив має вигляд [5,3,2,6,7,9], а повернутий індекс розділення — 4.
Виконайте рекурсивну операцію Operaції
Після того, як розбиття поверне індекс розділення, використовуйте його для поділу діапазону та запустіть швидке сортування для кожної половини. Ось чому це називається алгоритмом «Поділяй і володарюй». Рекурсія продовжується доти, доки кожен піддіапазон не містить одного елемента, після чого весь масив сортується.
Примітка: Швидке сортування працює з одним і тим самим масивом протягом усього процесу. У процесі не створюються нові масиви, що робить його алгоритмом сортування на місці.
Отже, ви телефонуєте розділ () функцію, пояснену вище, та використовувати її повернене значення для розділення масив на частини. Ось код, який це робить:
Зверніть увагу на дві умови захисту, виділені на скріншоті. left < index - 1 підтверджує, що принаймні два елементи залишаються з лівого боку, та index < right підтверджує те саме для правої частини. Без цих захисних елементів функція викликала б себе нескінченно для діапазонів з одного елемента.
function quickSort(items, left, right) { var index; if (items.length > 1) { index = partition(items, left, right); // index returned from partition if (left < index - 1) { // more elements on the left side of the pivot quickSort(items, left, index - 1); } if (index < right) { // more elements on the right side of the pivot quickSort(items, index, right); } } return items; } // first call to quick sort var items = [5, 3, 7, 6, 2, 9]; var result = quickSort(items, 0, items.length - 1); console.log(result);
вихід:
[ 2, 3, 5, 6, 7, 9 ]
Завершити швидке сортування Code
Об'єднання частин swap, partition та recursion дає повну реалізацію:
var items = [5, 3, 7, 6, 2, 9]; function swap(items, leftIndex, rightIndex) { var temp = items[leftIndex]; items[leftIndex] = items[rightIndex]; items[rightIndex] = temp; } function partition(items, left, right) { var pivot = items[Math.floor((right + left) / 2)], // middle element i = left, // left pointer j = right; // right pointer while (i <= j) { while (items[i] < pivot) { i++; } while (items[j] > pivot) { j--; } if (i <= j) { swap(items, i, j); // swapping two elements i++; j--; } } return i; } function quickSort(items, left, right) { var index; if (items.length > 1) { index = partition(items, left, right); // index returned from partition if (left < index - 1) { // more elements on the left side of the pivot quickSort(items, left, index - 1); } if (index < right) { // more elements on the right side of the pivot quickSort(items, index, right); } } return items; } // first call to quick sort var sortedArray = quickSort(items, 0, items.length - 1); console.log(sortedArray);
вихід:
[ 2, 3, 5, 6, 7, 9 ]
На скріншоті вище показано повну програму в редакторі разом із відсортованим масивом у консолі. Цю реалізацію було перевірено на вже відсортованому масиві, обернено відсортованому масиві, масивах, що містять дублікати та ідентичні значення, від'ємних числах, одному елементі та порожньому масиві, і вона повертає правильний результат у кожному випадку.
💡 Порада: Охоронець if (items.length > 1) перевіряє довжину всього масиву, а не поточного діапазону. Це працює тут, оскільки два рекурсивні виклики вже захищені left < index - 1 та index < right, Але if (left >= right) { return items; } є більш зрозумілою та безпечною умовою для написання нового коду.
Часова та просторова складність швидкого сортування
Кожен прохід розділення торкається кожного елемента в діапазоні один раз, тому один прохід коштує O(n). Загальна вартість, таким чином, залежить від того, скільки разів масив можна розділити, перш ніж діапазони стануть тривіальними.
| випадок | Часова складність | Коли це трапляється |
|---|---|---|
| кращий | O (n журнал n) | Кожен центр опори ділить свій діапазон на дві половини рівного розміру. |
| середній | O (n журнал n) | Випадково впорядкований вхід з розумним правилом повороту. |
| найгірше | O (n²) | Кожна точка повороту є найменшим або найбільшим значенням, що дає n рівнів рекурсії. |
Просторова складність дорівнює O(log n) для цієї версії на місці. Другий масив не виділяється, тому єдиною додатковою пам'яттю є стек рекурсії, а збалансоване розділення підтримує глибину цього стеку приблизно log₂(n) кадрів. У найгіршому випадку стек зростає до O(n) кадрів, тому дуже великі масиви можуть переповнювати стек викликів.
Два числа роблять це конкретним. Сортування 4,096 випадкових значень за допомогою наведеного вище коду використало приблизно 65 000 порівнянь проти теоретичного n·log₂(n) 49 152, а найглибша рекурсія досягла 24 кадрів, тоді як log₂(4096) дорівнює 12. Обидва показники знаходяться в межах малого постійного коефіцієнта, очікуваного для алгоритму O(n log n).
⚠️ Попередження: Твердження, що швидке сортування — це просто «алгоритм типу O(n log n)», є неповним. Його найгірший випадок — O(n²), і наївний першоелементний pivot потрапляє в цей найгірший випадок саме на тих вхідних даних, які ви, найімовірніше, отримаєте у виробництві: даних, які вже відсортовані.
Швидке сортування проти інших видів сортування Algorithms
Швидке сортування рідко є єдиним варіантом. У таблиці нижче його порівнюють з іншими алгоритмами, з якими ви, найімовірніше, зустрінетеся, щоб ви могли вибрати правильний для своїх даних.
| Алгоритм | кращий | середній | найгірше | Простір | Стабільний |
|---|---|---|---|---|---|
| Швидке сортування | O (n журнал n) | O (n журнал n) | O (n²) | O (журнал n) | Немає |
| Об’єднати сортування | O (n журнал n) | O (n журнал n) | O (n журнал n) | О (п) | Так |
| Сортування купи | O (n журнал n) | O (n журнал n) | O (n журнал n) | O (1) | Немає |
| Сортування вставки | О (п) | O (n²) | O (n²) | O (1) | Так |
| Bubble Сортування | О (п) | O (n²) | O (n²) | O (1) | Так |
| Сортування вибору | O (n²) | O (n²) | O (n²) | O (1) | Немає |
Швидке сортування зазвичай перемагає на практиці, оскільки його внутрішній цикл є щільним і він працює в кеш-дружніх суміжних діапазонах. Вибирайте сортування злиттям, коли вам потрібен гарантований O(n log n)-впорядкований або стабільний порядок, сортування купою, коли пам'ять надзвичайно обмежена, і сортування вставками для дуже малих або майже відсортованих масивів. Виробничі бібліотеки часто поєднують їх: вставне сортування починається зі швидкого сортування, перемикається на сортування купою, якщо рекурсія стає занадто глибокою, і завершується сортуванням вставками для малих діапазонів.
Як швидко сортувати об'єкти та рядки
Показана досі реалізація порівнює значення з < та >, що обмежує його числами. Реальні програми потребують сортування об'єкти за властивістю, рядками в алфавітному порядку або датами в хронологічному порядку. Виправлення полягає в переміщенні порівняння у зворотний виклик, точно так само, як вбудований sort() робить.
Компаратор отримує два значення та повертає від'ємне число, коли перше має бути першим, додатне число, коли друге має бути першим, та нуль, коли два значення еквівалентні. Заміна двох жорстко запрограмованих порівнянь викликами компаратора дозволяє алгоритму працювати з будь-яким типом даних.
function swap(items, i, j) { var temp = items[i]; items[i] = items[j]; items[j] = temp; } function partition(items, left, right, compare) { var pivot = items[Math.floor((right + left) / 2)], i = left, j = right; while (i <= j) { while (compare(items[i], pivot) < 0) { i++; } while (compare(items[j], pivot) > 0) { j--; } if (i <= j) { swap(items, i, j); i++; j--; } } return i; } function quickSort(items, left, right, compare) { if (left >= right) { return items; } // nothing left to split var index = partition(items, left, right, compare); if (left < index - 1) { quickSort(items, left, index - 1, compare); } if (index < right) { quickSort(items, index, right, compare); } return items; } function sort(items, compare) { compare = compare || function (a, b) { return a < b ? -1 : a > b ? 1 : 0; }; return quickSort(items, 0, items.length - 1, compare); } var numbers = [10, 9, 1, 100, 25]; console.log(sort(numbers, function (a, b) { return a - b; })); var names = ["Priya", "arun", "Bala", "chetan"]; console.log(sort(names, function (a, b) { return a.toLowerCase().localeCompare(b.toLowerCase()); })); var employees = [ { name: "Arun", salary: 52000 }, { name: "Bala", salary: 41000 }, { name: "Chetan", salary: 68000 } ]; console.log(sort(employees, function (a, b) { return a.salary - b.salary; }));
вихід:
[ 1, 9, 10, 25, 100 ]
[ 'arun', 'Bala', 'chetan', 'Priya' ]
[
{ name: 'Bala', salary: 41000 },
{ name: 'Arun', salary: 52000 },
{ name: 'Chetan', salary: 68000 }
]
Варто зазначити три деталі. Захист рекурсії тепер left >= right, що є правильним для будь-якого діапазону та не залежить від довжини зовнішнього масиву. Порівняння рядків використовує localeCompare() щоб символи з діакритикою та регістр оброблялися належним чином, а не за необробленим кодом. А оскільки швидке сортування нестабільне, записи, що мають спільну зарплату, можуть мінятися місцями; сортуйте за другим ключем, якщо для вас важливий початковий порядок.
Готові продовжувати? Зміцніть основи за допомогою JavaВступ до сценарію, потренуйте механіку вказівника в JavaЦикли скриптів, опрацювати більше практичний JavaПриклади коду скриптів, порівняйте реалізації в Сортування вставки та Сортування купиабо додайте статичні типи до цього алгоритму за допомогою TypeScript довідник.






