Целочисленный двоичный поиск

Целочисленный двоичный поиск (бинарный поиск) (англ. binary search) — алгоритм поиска объекта по заданному признаку в множестве объектов, упорядоченных по тому же самому признаку, работающий за логарифмическое время.

Схема бинарного поиска

Формулировка задачи

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

Принцип работы

Двоичный поиск заключается в том, что на каждом шаге множество объектов делится на две части и в работе остаётся та часть множества, где находится искомый объект. Или же, в зависимости от постановки задачи, мы можем остановить процесс, когда мы получим первый или же последний индекс вхождения элемента. Последнее условие — это левосторонний/правосторонний двоичный поиск.

Правосторонний/левосторонний целочисленный двоичный поиск

Для простоты дальнейших определений будем считать, что [math]a[0] = -\infty[/math] и что [math]a[n] = +\infty[/math].

Определение:

Правосторонний бинарный поиск (англ. rightside binary search) — бинарный поиск, с помощью которого мы ищем [math] \max\limits_{i \in [0,n]} \{i \mid a[i] \leqslant x\} [/math], где [math]a[/math] — массив, а [math]x[/math] — искомый ключ

Определение:

Левосторонний бинарный поиск (англ. leftside binary search) — бинарный поиск, с помощью которого мы ищем [math] \min\limits_{i \in [0,n]}\{i \mid a[i] \geqslant x\} [/math], где [math]a[/math] — массив, а [math]x[/math] — искомый ключ

Использовав эти два вида двоичного поиска, мы можем найти отрезок позиций [math][l,r][/math] таких, что [math]\forall i \in [l,r] : a[i] = x[/math] и [math] \forall i \notin [l,r] : a[i] \neq x [/math]

Например:

Задан отсортированный массив [math][1, 2, 2, 2, 2, 3, 5, 8, 9, 11], x = 2[/math].

Правосторонний поиск двойки выдаст в результате [math]5[/math], в то время как левосторонний выдаст [math]2[/math] (нумерация с единицы).

От сюда следует, что количество подряд идущих двоек равно длине отрезка [math][2;5][/math], то есть [math]4[/math].

Если искомого элемента в массиве нет, то правосторонний поиск выдаст минимальный элемент, больший искомого, а левосторонний наоборот, максимальный элемент, меньший искомого.

Алгоритм двоичного поиска

Идея поиска заключается в том, чтобы брать элемент посередине, между границами, и сравнивать его с искомым. Если искомое больше(в случае правостороннего — не меньше), чем элемент сравнения, то сужаем область поиска так, чтобы новая левая граница была равна индексу середины предыдущей области. В противном случае присваиваем это значение правой границе. Проделываем эту процедуру до тех пор, пока правая граница больше левой более чем на [math]1[/math]. В случае правостороннего бинарного поиска ответом будет индекс [math]l[/math], а в случае левостороннего — [math]r[/math].

Код

int binSearch(int[] a, int key)    // l, r - левая и правая границы
    int l = 0
    int r = len(a) + 1    
    while l < r - 1                // запускаем цикл
        m = (l + r) / 2            // m — середина области поиска
        if a[m] < key
            l = m
        else 
            r = m                  // сужение границ
    return r

В случае правостороннего поиска изменится знак сравнения при сужении границ на [math]a[m] \leqslant k[/math].

Инвариант цикла: пусть левый индекс не больше искомого элемента, а правый — строго больше, тогда если [math]l = r - 1[/math], то понятно, что [math]l[/math] — самое правое вхождение (так как следующее уже больше).

Несколько слов об эвристиках

Эвристика с завершением поиска, при досрочном нахождении искомого элемента

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

Эвристика с запоминанием ответа на предыдущий запрос

Пусть дан отсортированный массив чисел, упорядоченных по неубыванию. Также пусть запросы приходят в таком порядке, что каждый следующий не меньше, чем предыдущий. Для ответа на запрос будем использовать левосторонний двоичный поиск. При этом после того как обработался первый запрос, запомним чему равно [math]l[/math], запишем его в переменную [math]startL[/math]. Когда будем обрабатывать следующий запрос, то проинициализируем левую границу как [math]startL[/math]. Заметим, что все элементы, которые лежат не правее [math]startL[/math], строго меньше текущего искомого элемента, так как они меньше предыдущего запроса, а значит и меньше текущего. Значит инвариант цикла выполнен.

Применение двоичного поиска на неотсортированных массивах

Применение поиска на циклически сдвинутом отсортированном массиве

Пусть отсортированный по возрастанию массив [math]a[0..n][/math], все элементы которого различны, был циклически сдвинут, тогда полученный массив состоит из двух отсортированных частей. Используем двоичный поиск, чтобы найти индекс последнего элемента левой части массива. Для этого в реализации двоичного поиска заменим условие в [math]if[/math] на [math]a[m] \gt a[n][/math], тогда в [math]l[/math] будет содержаться искомый индекс:

int l = 0
int r = n + 1    
while l < r - 1                // Запускаем цикл...
    m = (l + r) / 2            // m — середина области поиска.
    if a[m] > a[n]             // Сужение границ..
        l = m
    else 
        r = m
int x = l                      // x — искомый индекс.

Затем воспользуемся двоичным поиском искомого элемента [math]key[/math], запустив его на той части массива, в которой он находится: на [math][0, x][/math] или на [math][x + 1, n][/math]. Для определения нужной части массива сравним [math]key[/math] с первым и с последним элементами массива:

if key > a[0]               // Если key в левой части...
    l = 0
    r = x + 1
if key < a[n]               // Если key в правой части...
    l = x + 1
    r = n + 1

Время выполнения данного алгоритма — [math]O(2\log n)=O(\log n)[/math].

Применение поиска на массиве, отсортированном по возрастанию, в конец которого приписан массив, отсортированный по убыванию

Найдем индекс последнего элемента массива, отсортированного по возрастанию, воспользовавшись двоичным поиском, условие в [math]if[/math] в котором изменено на [math]a[m] \gt a[m - 1][/math]. Тогда в [math]l[/math] будет содержаться искомый индекс:

int l = 0
int r = n + 1    
while l < r - 1                // Запускаем цикл...
    m = (l + r) / 2            // m — середина области поиска.
    if a[m] > a[m - 1]             // Сужение границ...
        l = m
    else 
        r = m
int x = l                      // x — искомый индекс.

Затем запустим левосторонний двоичный поиск для каждого массива отдельно: для элементов [math][0..x][/math] и для элементов [math][x+1..n][/math]. Для массива, отсортированного по убыванию используем двоичный поиск, измененнив условие в [math]if[/math] на [math]a[m] \gt key[/math].

Время выполнения алгоритма — [math]O(3\log n)=O(\log n)[/math].

Применение поиска на двух отсортированных по возрастанию массивах, записанных один в конец другого

Найдем индекс последнего элемента левого массива, заменив условие в [math]if[/math] на [math]a[m] \lt a[m-1][/math]. Так мы найдем единственный элемент в массиве, который меньше предыдущего элемента (все остальные элементы больше предыдущего, так как массивы отсортированы по возрастанию). Однако такой алгоритм не будет работать, если левый массив длиннее, чем правый, и [math]last[/math] будет равняться начальному значению [math]l[/math]. Поэтому будем запускать такой алгоритм рекурсивно, если [math]last[/math] равно начальному значению [math]l[/math], беря за новое начальное значение [math]l[/math] середину массива. Таким образом мы запустим бинарный поиск еще [math]O(\log n)[/math] раз, постоянно уменьшая массив в два раза. Тогда через [math]O(\log n)[/math] итераций либо левый массив перестанет быть длиннее, чем правый, и значение [math]last[/math] окажется отличным от [math]a[/math] (начальное значение [math]l[/math]), либо длина массива станет равной двум и рекурсия потеряет всякий смысл (если в таком случае [math]last[/math] останется равным [math]a[/math], то, значит, что первый элемент правого массива больше последнего элемента левого массива. Тогда два массива будут являться одним массивом отсортированным по возрастанию). После выполнения этого алгоритма [math]last[/math] и будет номером последнего элемента из левого массива.

// Поиск последнего элемента левого массива
 int a = 0
 int b = n + 1
 function indexOfLastLeftArrayElement(int a,int b)
   int l = a
   int r = b    
   while l < r - 1                // Запускаем цикл...
       m = (l + r) / 2            // m — середина области поиска.
       if a[m] < a[m - 1]             // Сравнение с предыдущим...
           l = m
       else 
           r = m
   int last = l
   if last == a and r - (a + b) / 2 > 1
     indexOfLastLeftArrayElement((a + b) / 2, r)

Проверим, равен ли [math]last[/math] [math]a[/math]. Если да, то запустим бинарный поиск на массиве от [math]0[/math] до [math]n[/math]. Иначе, зная номер последнего элемента левого массива, запустим два раза левосторонний бинарный поиск: на массиве от [math]0[/math] до [math]last[/math], и на массиве от [math]last + 1[/math] до [math]n[/math].

Время выполнения алгоритма — [math]O(\log^2 n)[/math] (мы запускаем бинарный поиск, который требует [math]O(\log n)[/math] времени [math]O(\log n)[/math] раз).

Применение поиска на циклически сдвинутом массиве, образованном приписыванием отсортированного по убыванию массива в конец отсортированного по возрастанию

После циклического сдвига мы получим массив [math]a[0..n][/math], образованный из трех частей: отсортированных по возрастанию-убыванию-возрастанию или по убыванию-возрастанию-убыванию. Поэтому с помощью двоичного поиска мы ищем индексы максимального и минимального элементов массива, заменив условие в [math]if[/math] на [math]a[m] \gt a[m - 1][/math] (ответ будет записан в [math]l[/math]) или на [math]a[m] \gt a[m + 1][/math] (ответ будет записан в [math]r[/math]) соответственно:

// Поиск максимума...
int l = 0
int r = n + 1    
while l < r - 1                // Запускаем цикл...
    m = (l + r) / 2            // m — середина области поиска.
    if a[m] > a[m - 1]             // Сужение границ..
        l = m
    else 
        r = m
int max = l

// Поиск минимума...
int l = 0
int r = n + 1    
while l < r - 1                // Запускаем цикл...
    m = (l + r) / 2            // m — середина области поиска.
    if a[m] > a[m + 1]             // Сужение границ..
        l = m
    else 
        r = m
int min = r

Затем, в зависимости от расположения частей (можно узнать, сравнив [math]min[/math] и [math]max[/math]), запустим двоичный поиск для каждой части отдельно аналогично задаче о поиске элемента на массиве, отсортированном по возрастанию, в конец которого приписан массив, отсортированный по убыванию.

Время выполнения данного алгоритма — [math]O(5\log n)[/math].

См. также

• Вещественный двоичный поиск
• Троичный поиск
• Поиск с помощью золотого сечения
• Интерполяционный поиск

Источники информации

• Д. Кнут - Искусство программирования (Том 3, 2-е издание)
• Википедия - двоичный поиск
• Интересная статья про типичные ошибки
• Бинарный поиск на algolist