使用二进制搜索将字符串插入到已排序的字符串数组中

Question

I have the following alphabetically sorted array of strings:

let collection = ["ABC", "BCD", "CAB", "FGH", "JKL", "ZKL"];

I want to insert the string "CQW" inside the collection whilst preserving the sorted order but without having to sort the whole array all over again.

So I would like to have ["ABC", "BCD", "CAB", "CQW", "FGH", "JKL", "ZKL"]; after the insertion completed in O(log n) time.

I figured it would be a good idea to calculate the index at which I need to insert the element using binary search.

I have found the following code for binary search which retrieves the index of a string if it is existent inside a collection:

 function binarySearch(items, value) { let startIndex = 0; let stopIndex = items.length - 1; let middle = Math.floor((stopIndex + startIndex) / 2); while (items[middle] != value && startIndex < stopIndex) { //adjust search area if (value < items[middle]) { stopIndex = middle - 1; } else if (value > items[middle]) { startIndex = middle + 1; } //recalculate middle middle = Math.floor((stopIndex + startIndex) / 2); } // Return -1 if element is not in collection return (items[middle] != value) ? -1 : middle; } let collection = ["ABC", "BCD", "CAB", "FGH", "JKL", "ZKL"]; console.log(binarySearch(collection, "CQW"));

However, I have been struggling with modifying it so that it returns the precise index at which the string needs to be inserted. How can this be modified so that it works? Is binary search the most efficient way to do this?

Answer 1

The middle value should tell you where to put it. Modify the function's return value so it tells you if it's already in the collection as well

 function binarySearch(items, value) { console.log('Searching for '+value) let startIndex = 0; let stopIndex = items.length - 1; let middle = Math.floor((stopIndex + startIndex) / 2); while (items[middle] != value && startIndex < stopIndex) { //adjust search area if (value < items[middle]) { stopIndex = middle - 1; } else if (value > items[middle]) { startIndex = middle + 1; } //recalculate middle middle = Math.floor((stopIndex + startIndex) / 2); } // Return -1 if element is not in collection // return (items[middle] != value) ? -1 : middle; return { found: items[middle] == value, middle: middle } } let collection = ["ABC", "BCD", "CAB", "FGH", "JKL", "ZKL"]; let item = "CQW" result= binarySearch(collection, item); console.log(result) if(!result.found){ console.log('Adding '+item+' at index '+result.middle) collection.splice(result.middle, 0, item); } console.log(collection)

Output

Searching for CQW
{found: false, middle: 3}
Adding CQW at index 3
["ABC", "BCD", "CAB", "CQW", "FGH", "JKL", "ZKL"]

Answer 2

Since you're inserting into an array you are always going to have a worst case of O(n) in just moving values around "after" the insertion (+ an additional n or log n for finding the place to insert the value at). So i would either just append the value at one end of the array and then sort it with insertion sort (since insertion sort is actually one of the faster algorithms for almost-sorted input data).

 const insertionSort = (inputArr) => { const length = inputArr.length; for (let i = 1; i < length; i++) { const key = inputArr[i]; let j = i - 1; while (j >= 0 && inputArr[j] > key) { inputArr[j + 1] = inputArr[j]; j = j - 1; } inputArr[j + 1] = key; } return inputArr; }; let collection = ["ABC", "BCD", "CAB", "FGH", "JKL", "ZKL"]; collection.push("CQW"); console.log(insertionSort(collection));

Or, if you tend to end up with HUGE arrays and need O(n) worst case complexity for insertion; then i would move to an always sorted doubly-linked list instead.

 const linkedList = (value, next) => ({prev: null, value, next}); const insert = (node, value) => { if (node === null) { return false; } if (node.value < value) { return insert(node.next, value); } const newNode = linkedList(value, node); newNode.prev = node.prev; newNode.prev.next = newNode; node.prev = newNode; return true; } const arrayToList = (arr) => arr.reverse().reduce((next, el) => { const list = linkedList(el, next); if (next) { next.prev = list; } return list; }, null); const printList = (list) => { const arr = []; let node = list; while (node) { arr.push(node.value); node = node.next; } console.log(arr); }; const collection = ["ABC", "BCD", "CAB", "FGH", "JKL", "ZKL"]; const list = arrayToList(collection); insert(list, "CQW"); printList(list); // Some function that arent't used in the example // but are very usefull if you decided to use this solution const get = (list, index) => { let node = list; for (let i = 0; node; i++) { if (i === index) { return node.value; } node = node.next; } return null; } const set = (list, index, value) => { let node = list; for (let i = 0; node; i++) { if (i === index) { node.value = value; return true; } node = node.next; } return false; } const remove = (list, value) => { if (node === null) { return false; } if (node.value === value) { node.prev.next = node.next; node.next.prev = node.prev; return true; } return remove(node.next, value); } const getIndex = (list, value) => { let node = list; for (let i = 0; node; i++) { if (node.value === value) { return i; } node = node.next; } return -1; }