Ефективний спосіб вставити число в відсортований масив чисел?

У мене є відсортований масив JavaScript, і хочу вставити ще один елемент у масив, таким чином отриманий масив залишається відсортованим. Я, безумовно, міг реалізувати просту функцію вставки в стилі quicksort:

var array = [1,2,3,4,5,6,7,8,9];
var element = 3.5;
function insert(element, array) {
  array.splice(locationOf(element, array) + 1, 0, element);
  return array;
}

function locationOf(element, array, start, end) {
  start = start || 0;
  end = end || array.length;
  var pivot = parseInt(start + (end - start) / 2, 10);
  if (end-start <= 1 || array[pivot] === element) return pivot;
  if (array[pivot] < element) {
    return locationOf(element, array, pivot, end);
  } else {
    return locationOf(element, array, start, pivot);
  }
}

console.log(insert(element, array));

[ПОПЕРЕДЖЕННЯ] цей код має помилку при спробі вставити на початок масиву, наприклад insert(2, [3, 7 ,9]) видає неправильні [3, 2, 7, 9].

Однак я помітив, що реалізація функції Array.sort потенційно може зробити це для мене, і в основному:

var array = [1,2,3,4,5,6,7,8,9];
var element = 3.5;
function insert(element, array) {
  array.push(element);
  array.sort(function(a, b) {
    return a - b;
  });
  return array;
}

console.log(insert(element, array));

Чи є вагомі підстави вибрати першу реалізацію над другою?

Редагувати : Зауважте, що для загального випадку вставка O (log (n)) (як реалізовано в першому прикладі) буде швидшою, ніж алгоритм загального сортування; однак це не обов'язково стосується JavaScript, зокрема. Зауважте, що:

• Найкращим випадком для декількох алгоритмів вставки є O (n), який все ще суттєво відрізняється від O (log (n)), але не настільки поганий, як O (n log (n)), як зазначено нижче. Це зводиться до конкретного алгоритму сортування (див. Реалізацію Javascript Array.sort?) )
• Метод сортування в JavaScript - це основна функція, тому потенційно реалізуючи величезні переваги - O (log (n)) з величезним коефіцієнтом, все ще може бути набагато гіршим, ніж O (n) для наборів даних досить розміру.

Як єдину точку даних, для ударів я перевірив це, вставляючи 1000 випадкових елементів у масив із 100000 заздалегідь відсортованих чисел за допомогою двох методів за допомогою Chrome у Windows 7:

First Method:
~54 milliseconds
Second Method:
~57 seconds

Тож, принаймні, у цій установці нативний метод цього не компенсує. Це справедливо навіть для невеликих наборів даних, вставляючи 100 елементів у масив 1000:

First Method:
1 milliseconds
Second Method:
34 milliseconds

Простий ( демонстраційний ):

function sortedIndex(array, value) {
    var low = 0,
        high = array.length;

    while (low < high) {
        var mid = (low + high) >>> 1;
        if (array[mid] < value) low = mid + 1;
        else high = mid;
    }
    return low;
}

Дуже хороше і чудове запитання з дуже цікавою дискусією! Я також використовував цю Array.sort()функцію після натискання одного елемента в масиві з деякими тисячами об'єктів.

Мені довелося розширити вашу locationOfфункцію з моїх цілей через наявність складних об'єктів, а отже і необхідності функції порівняння, як у Array.sort():

function locationOf(element, array, comparer, start, end) {
    if (array.length === 0)
        return -1;

    start = start || 0;
    end = end || array.length;
    var pivot = (start + end) >> 1;  // should be faster than dividing by 2

    var c = comparer(element, array[pivot]);
    if (end - start <= 1) return c == -1 ? pivot - 1 : pivot;

    switch (c) {
        case -1: return locationOf(element, array, comparer, start, pivot);
        case 0: return pivot;
        case 1: return locationOf(element, array, comparer, pivot, end);
    };
};

// sample for objects like {lastName: 'Miller', ...}
var patientCompare = function (a, b) {
    if (a.lastName < b.lastName) return -1;
    if (a.lastName > b.lastName) return 1;
    return 0;
};

У вашому коді помилка. Він повинен читати:

function locationOf(element, array, start, end) {
  start = start || 0;
  end = end || array.length;
  var pivot = parseInt(start + (end - start) / 2, 10);
  if (array[pivot] === element) return pivot;
  if (end - start <= 1)
    return array[pivot] > element ? pivot - 1 : pivot;
  if (array[pivot] < element) {
    return locationOf(element, array, pivot, end);
  } else {
    return locationOf(element, array, start, pivot);
  }
}

Без цього виправлення код ніколи не зможе вставити елемент на початку масиву.

Я знаю, що це старе питання, на яке вже є відповідь, і є ряд інших гідних відповідей. Я бачу деякі відповіді, які пропонують вирішити цю проблему, шукаючи правильний індекс вставки в O (log n) - ви можете, але ви не можете вставити цей час, тому що масив потрібно частково скопіювати, щоб зробити простір.

Підсумок: Якщо вам дійсно потрібні O (log n) вставлення та видалення в відсортований масив, вам потрібна інша структура даних - не масив. Ви повинні використовувати B-дерево . Підвищення продуктивності, яке ви отримаєте від використання B-Tree для великого набору даних, дозволить уникнути будь-якого з запропонованих тут удосконалень.

Якщо потрібно використовувати масив. Я пропоную наступний код, заснований на сортуванні вставки, який працює, якщо і лише якщо масив вже відсортований. Це корисно у випадку, коли вам потрібно вдаватися після кожної вставки:

function addAndSort(arr, val) {
    arr.push(val);
    for (i = arr.length - 1; i > 0 && arr[i] < arr[i-1]; i--) {
        var tmp = arr[i];
        arr[i] = arr[i-1];
        arr[i-1] = tmp;
    }
    return arr;
}

Він повинен працювати в O (n), що, на мою думку, найкраще, що ви можете зробити. Було б приємніше, якби js підтримував декілька завдань. ось приклад для гри:

Оновлення:

це може бути швидше:

function addAndSort2(arr, val) {
    arr.push(val);
    i = arr.length - 1;
    item = arr[i];
    while (i > 0 && item < arr[i-1]) {
        arr[i] = arr[i-1];
        i -= 1;
    }
    arr[i] = item;
    return arr;
}

Оновлено посилання JS Bin

Ваша функція вставки передбачає, що даний масив відсортований, він шукає безпосередньо місце, куди можна вставити новий елемент, як правило, просто переглянувши декілька елементів масиву.

Загальна функція сортування масиву не може приймати ці ярлики. Очевидно, що принаймні потрібно перевірити всі елементи в масиві, щоб побачити, чи вони вже правильно впорядковані. Сам цей факт загальний сортування робить повільніше, ніж функція вставки.

Загальний алгоритм сортування зазвичай в середньому O (n ⋅ log (n)), і залежно від реалізації він може бути насправді найгіршим випадком, якщо масив уже відсортований, що призводить до складності O (n ² ) . Безпосередньо пошук позиції вставки натомість має лише складність O (log (n)) , тому це завжди буде набагато швидше.

Для невеликої кількості предметів різниця досить тривіальна. Однак якщо ви вставляєте багато елементів або працюєте з дуже великим масивом, виклик .sort () після кожної вставки спричинить величезну кількість накладних витрат.

Я закінчив писати досить чітку двійкову функцію пошуку / вставки саме для цієї мети, тому я подумав, що поділюсь цим. Оскільки він використовує whileцикл замість рекурсії, для додаткових викликів функцій немає підслуховування, тому я думаю, що продуктивність буде навіть кращою, ніж будь-який із спочатку розміщених методів. І він за замовчуванням емулює Array.sort()компаратор за замовчуванням, але при бажанні приймає функцію спеціального компаратора.

function insertSorted(arr, item, comparator) {
    if (comparator == null) {
        // emulate the default Array.sort() comparator
        comparator = function(a, b) {
            if (typeof a !== 'string') a = String(a);
            if (typeof b !== 'string') b = String(b);
            return (a > b ? 1 : (a < b ? -1 : 0));
        };
    }

    // get the index we need to insert the item at
    var min = 0;
    var max = arr.length;
    var index = Math.floor((min + max) / 2);
    while (max > min) {
        if (comparator(item, arr[index]) < 0) {
            max = index;
        } else {
            min = index + 1;
        }
        index = Math.floor((min + max) / 2);
    }

    // insert the item
    arr.splice(index, 0, item);
};

Якщо ви відкриті для використання інших бібліотек, lodash надає sortedIndex та sortedLastIndex функції, які можна використовувати замість whileциклу. Два потенційних недоліки: 1) продуктивність не настільки хороша, як мій метод (я думав, не впевнений, наскільки це гірше) і 2) він не приймає спеціальну функцію порівняння, лише метод отримання значення для порівняння (я використовую компаратор за замовчуванням, я вважаю).

Ось кілька думок: По-перше, якщо ви щиро стурбовані виконуваним кодом, не забудьте знати, що відбувається, коли ви зателефонуєте на вбудовані функції! Я не знаю, як внизу в JavaScript, але швидкий google функції сплайс повернув це , що, схоже, вказує на те, що ви створюєте цілий новий масив кожного виклику! Я не знаю, чи це насправді має значення, але це, безумовно, пов'язано з ефективністю. Я бачу, що Бретон у своїх коментарях вже вказав на це, але це, безумовно, стосується будь-якої функції, що маніпулює масивом, яку ви виберете.

У будь-якому разі, насправді вирішити проблему.

Коли я прочитав, що ти хотів сортувати, моя перша думка - використовувати сортування вставки! . Це зручно, оскільки він працює в лінійний час за відсортованими або майже відсортованими списками . Оскільки у ваших масивах буде лише 1 елемент, який не впорядкований, він вважається майже відсортованим (за винятком, ну, масивів розміром 2 або 3 або будь-якого іншого, але в цьому випадку, c'mon). Тепер реалізація сорту не надто погана, але це клопоти, з якими ви, можливо, не захочете мати справу, і, знову ж таки, я не знаю нічого про JavaScript, і чи буде це легко чи важко чи що. Це знімає потребу у вашій функції пошуку, і ви просто натискаєте (як запропонував Бретон).

По-друге, ваша функція пошуку "quicksort-esque", здається, є бінарним алгоритмом пошуку ! Це дуже приємний алгоритм, інтуїтивно зрозумілий і швидкий, але з одним уловом: його, як відомо, важко реалізувати правильно. Я не наважусь сказати, чи правильно це чи ні (сподіваюся, звичайно! :)), але будьте обережні, якщо ви хочете його використовувати.

У будь-якому випадку, підсумок: використання "push" з сортуванням вставки буде працювати в лінійний час (якщо припустити, що решта масиву відсортовано) та уникнути будь-яких брудних вимог до алгоритму двійкового пошуку. Я не знаю, чи це найкращий спосіб (основна реалізація масивів, можливо, божевільна вбудована функція робить це краще, хто знає), але мені це здається розумним. :) - Агор.

Ось порівняння чотирьох різних алгоритмів для цього: https://jsperf.com/sorted-array-insert-comporder/1

Алгоритми

• Наївно: просто натисніть і сортуйте () згодом
• Лінійний: повторіть масив та вставте, де це доречно
• Бінарний пошук: взято з https://stackoverflow.com/a/20352387/154329
• "Швидке сортування, як": очищений розчин від синтетичного нуля ( https://stackoverflow.com/a/18341744/154329 )

Наївність завжди жахлива. Здається, для невеликих розмірів масиву, інші три не дуже відрізняються, але для великих масивів останні 2 перевершують простий лінійний підхід.

Ось версія, яка використовує lodash.

const _ = require('lodash');
sortedArr.splice(_.sortedIndex(sortedArr,valueToInsert) ,0,valueToInsert);

Примітка: sortedIndex здійснює двійковий пошук.

Найкраща структура даних, яку я можу придумати, - це індексований пропускний список який підтримує властивості вставки зв'язаних списків із ієрархічною структурою, яка дозволяє здійснювати операції в часі журналу. У середньому пошук, вставка та пошук у довільному доступі можна здійснити за O (log n) час.

Порядок статистика дерево дозволяє час індексації журналу з функцією рангу.

Якщо вам не потрібен випадковий доступ, але вам потрібна вставка O (log n) та пошук ключів, ви можете скинути структуру масиву і використовувати будь-яке дерево двійкового пошуку .

Жоден із відповідей, які використовують, array.splice()взагалі не ефективний, оскільки це в середньому O (n) час. Яка складність у часі array.splice () у Google Chrome?

Ось моя функція, використовує двійковий пошук, щоб знайти предмет, а потім вставити належним чином:

function binaryInsert(val, arr){
    let mid, 
    len=arr.length,
    start=0,
    end=len-1;
    while(start <= end){
        mid = Math.floor((end + start)/2);
        if(val <= arr[mid]){
            if(val >= arr[mid-1]){
                arr.splice(mid,0,val);
                break;
            }
            end = mid-1;
        }else{
            if(val <= arr[mid+1]){
                arr.splice(mid+1,0,val);
                break;
            }
            start = mid+1;
        }
    }
    return arr;
}

console.log(binaryInsert(16, [
    5,   6,  14,  19, 23, 44,
   35,  51,  86,  68, 63, 71,
   87, 117
 ]));

Не переробляйте після кожного елемента, його надмірність ..

Якщо є лише один елемент для вставки, ви можете знайти місце для вставки, використовуючи двійковий пошук. Потім скористайтеся memcpy або подібним способом для копіювання решти елементів, щоб звільнити місце для вставленого. Двійковий пошук - O (log n), а копія - O (n), даючи O (n + log n). Використовуючи вищезазначені методи, ви робите повторну сортування після кожного вставки, що є O (n log n).

Це важливо? Скажімо, ви випадковим чином вставляєте k елементів, де k = 1000. Відсортований список становить 5000 елементів.

• Binary search + Move = k*(n + log n) = 1000*(5000 + 12) = 5,000,012 = ~5 million ops
• Re-sort on each = k*(n log n) = ~60 million ops

Якщо k елементи, які потрібно вставити, надходять будь-коли, тоді потрібно виконати пошук + переміщення. Однак якщо вам надано список k елементів, які потрібно вставити в відсортований масив - достроково - тоді ви можете зробити ще краще. Сортуйте k елементів окремо від уже відсортованого n масиву. Потім зробіть сортування сканування, при якому ви переміщуєте обидва відсортовані масиви одночасно, об’єднуючи один в інший. - Сортування в один крок = k log k + n = 9965 + 5000 = ~ 15 000 ops

Оновлення: Що стосується вашого питання.
First method = binary search+move = O(n + log n). Second method = re-sort = O(n log n)Точно пояснює терміни, які ви отримуєте.

function insertOrdered(array, elem) {
    let _array = array;
    let i = 0;
    while ( i < array.length && array[i] < elem ) {i ++};
    _array.splice(i, 0, elem);
    return _array;
}