Учебники

17) Алгоритм быстрой сортировки

Что такое быстрая сортировка?

Алгоритм быстрой сортировки следует принципу «разделяй и властвуй». Он делит элементы на более мелкие части на основе некоторых условий и выполняет операции сортировки на этих разделенных меньших частях.

Алгоритм быстрой сортировки является одним из самых популярных и популярных алгоритмов на любом языке программирования. Но, если вы являетесь разработчиком JavaScript, вы можете услышать о sort (), который уже доступен в JavaScript. Тогда вы могли подумать, зачем нужен этот алгоритм быстрой сортировки. Чтобы понять это, сначала нам нужно, что такое сортировка и что такое сортировка по умолчанию в JavaScript.

Что такое сортировка?

Сортировка — это не что иное, как упорядочение элементов в нужном нам порядке. Вы, возможно, сталкивались с этим в школьные или студенческие дни. Подобно расположению чисел от меньшего к большему (по возрастанию) или от большего к меньшему (по убыванию) — это то, что мы видели до сих пор, и называется сортировкой.

Сортировка по умолчанию в JavaScript

Как упоминалось ранее, JavaScript имеет функцию sort () . Давайте рассмотрим пример с несколькими массивами элементов, такими как [5,3,7,6,2,9], и хотим отсортировать элементы этого массива в порядке возрастания. Просто вызовите sort () для массива items, и он отсортирует элементы массива в порядке возрастания.

Код:

var items = [5,3,7,6,2,9];
console.log(items.sort());
//prints [2, 3, 5, 6, 7, 9]

В чем причина выбора быстрой сортировки по умолчанию для сортировки () в JavaScript

Хотя sort () дает желаемый результат, проблема заключается в способе сортировки элементов массива. По умолчанию sort () в JavaScript использует сортировку вставкой с помощью V8 Engine Chrome и сортировку слиянием с помощью Mozilla Firefox и Safari .

Но, другое это не подходит, если вам нужно отсортировать большое количество элементов. Таким образом, решение заключается в использовании быстрой сортировки для большого набора данных.

Итак, чтобы полностью понять, вам нужно знать, как работает Quick sort, и давайте сейчас рассмотрим это подробно.

Что такое быстрая сортировка?

Быстрая сортировка выполняется по алгоритму « Разделяй и властвуй» . Он делит элементы на более мелкие части на основе некоторого условия и выполняет операции сортировки на этих разделенных меньших частях. Следовательно, он хорошо работает для больших наборов данных. Итак, вот шаги, как быстрая сортировка работает в простых словах.

  1. Сначала выберите элемент, который должен называться сводным элементом.
  2. Затем сравните все элементы массива с выбранным элементом поворота и расположите их так, чтобы элементы, меньшие, чем элемент поворота, были слева от него, а элементы больше, чем сводные — справа.
  3. Наконец, выполните те же операции с левым и правым боковыми элементами к элементу поворота.

Итак, это основная схема быстрой сортировки. Вот шаги, которые необходимо выполнить один за другим для выполнения быстрой сортировки.

Как работает QuickSort

  1. Сначала найдите элемент «pivot» в массиве.
  2. Начните левый указатель с первого элемента массива.
  3. Начните правый указатель на последнем элементе массива.
  4. Сравните элемент, указывающий с левым указателем, и, если он меньше, чем элемент поворота, переместите левый указатель вправо (добавьте 1 к левому указателю). Продолжайте до тех пор, пока левый боковой элемент не станет больше или равен элементу поворота.
  5. Сравните элемент, указывающий с правым указателем, и, если он больше, чем элемент поворота, переместите правый указатель влево (вычтите 1 из правого индекса). Продолжайте до тех пор, пока правый боковой элемент не станет меньше или равен элементу поворота.
  6. Убедитесь, что левый указатель меньше или равен правому указателю, а затем увидел элементы в местах этих указателей.
  7. Увеличьте левый указатель и уменьшите правый указатель.
  8. Если индекс левого указателя все еще меньше, чем индекс правого указателя, то повторите процесс; иначе вернуть индекс левого указателя.

Итак, давайте посмотрим на эти шаги на примере. Давайте рассмотрим массив элементов, которые нам нужно отсортировать, это [5,3,7,6,2,9].

Определить опорный элемент

Но прежде чем приступить к быстрой сортировке, выбор основного элемента играет важную роль. Если вы выберете первый элемент в качестве элемента pivot, то он даст худшую производительность в отсортированном массиве. Таким образом, всегда желательно выбрать средний элемент (длина массива, разделенная на 2) в качестве основного элемента, и мы делаем то же самое.

Вот шаги для выполнения быстрой сортировки, которая показана на примере [5,3,7,6,2,9].

ШАГ 1: Определить ось как средний элемент. Итак, 7 — это основной элемент.

ШАГ 2: Начните левый и правый указатели как первый и последний элементы массива соответственно. Таким образом, левый указатель указывает на 5 в индексе 0, а правый указатель указывает на 9 в индексе 5.

ШАГ 3: Сравните элемент по левому указателю с элементом поворота. С 5 <6 сдвиньте левый указатель вправо на индекс 1.

ШАГ 4: Теперь все еще 3 <6, поэтому переместите левый указатель на еще один указатель вправо. Так что теперь 7> 6 прекращают увеличивать левый указатель, и теперь левый указатель имеет индекс 2.

ШАГ 5: Теперь сравните значение в правом указателе с элементом pivot. С 9> 6 переместите правый указатель влево. Теперь, когда 2 <6, перестаньте двигать правый указатель.

ШАГ 6. Поменяйте местами оба значения, присутствующие в левом и правом указателях.

ШАГ 7: переместите оба указателя еще на один шаг.

ШАГ 8: так как 6 = 6, переместите указатели на еще один шаг и остановитесь, когда левый указатель пересекает правый указатель и возвращает индекс левого указателя.

Таким образом, здесь, основываясь на вышеупомянутом подходе, нам нужно написать код для замены элементов и разбиения массива, как указано выше.

Код для замены двух чисел в JavaScript:

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); //swap 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 result = quickSort(items, 0, items.length - 1);

Полный код быстрой сортировки:

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); //sawpping 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); //prints [2,3,5,6,7,9]

ПРИМЕЧАНИЕ. Быстрая сортировка выполняется с временной сложностью O (nlogn).