Ответ
Бинарный поиск имеет логарифмическую временную сложность O(log n).
Основное условие применения: алгоритм работает только на отсортированных данных (массивах, срезах).
Принцип работы: На каждом шаге алгоритм сравнивает искомый элемент со средним элементом коллекции. Если они не равны, то в зависимости от результата сравнения отбрасывается либо левая, либо правая половина коллекции. Таким образом, область поиска сокращается вдвое на каждой итерации.
Применение в Go:
Вместо написания своей реализации, рекомендуется использовать готовые функции из пакета sort, которые эффективны и протестированы:
import (
"fmt"
"sort"
)
func main() {
slice := []int{2, 5, 8, 12, 16, 23, 38, 56, 72}
target := 23
// sort.SearchInts возвращает индекс, куда можно вставить target
// с сохранением сортировки. Если элемент найден, это его индекс.
index := sort.SearchInts(slice, target)
if index < len(slice) && slice[index] == target {
fmt.Printf("Элемент %d найден по индексу %dn", target, index)
} else {
fmt.Printf("Элемент %d не найденn", target)
}
}Ответ 18+ 🔞
Ну ты посмотри, какой умный дядя придумал этот бинарный поиск! Сука, гениально же, блядь! Вместо того чтобы, как конченый, перебирать всё подряд, он берёт и делит пополам, как последний пирог на вечеринке. Сложность у него O(log n) — это значит, что даже если у тебя данных овердохуища, он их разберёт быстрее, чем ты успеешь сказать «ёпта».
Но есть одна, блядь, важная деталь, которую забывают все распиздяи: алгоритм этот работает ТОЛЬКО НА ОТСОРТИРОВАННЫХ данных! Никаких «ой, а у меня тут вразнобой, но я попробую». Не попробуешь, пизда. Он тебе нахуй ничего не найдёт, будет метаться, как Герасим после Муму.
Как он, сука, работает: Берёт твой отсортированный массив, смотрит на самый серединный элемент и спрашивает: «Ну что, ты тот самый, кого мы ищем?». Если нет — а он почти всегда нет, блядь — то смотрит: искомый элемент больше или меньше? Если больше — отбрасывает всю левую половину, как ненужный хлам. Если меньше — нахуй правую. И так повторяет, пока не найдёт или пока не поймёт, что элемента тут вообще нет. Каждый раз область поиска сокращается вдвое — вот и вся магия, в рот меня чих-пых!
А теперь, внимание, самое сочное: в Go, блядь, не нужно писать эту хуйню самому! Там уже всё придумали за тебя, ленивую жопу. Есть пакет sort, в котором лежат готовые, отполированные до блеска функции. Бери и пользуйся, как царь!
import (
"fmt"
"sort"
)
func main() {
slice := []int{2, 5, 8, 12, 16, 23, 38, 56, 72}
target := 23
// sort.SearchInts — это, блядь, волшебная палочка.
// Она тебе вернёт индекс, куда можно было бы воткнуть target, чтобы не сломать сортировку.
// Если элемент таки есть — это и будет его настоящий индекс.
index := sort.SearchInts(slice, target)
// А вот тут, хитрая жопа, нужно проверить, что мы не вышли за границы
// и что по этому индексу лежит именно то, что мы искали.
// А то мало ли, он тебе индекс какого-нибудь левого соседа подсунет.
if index < len(slice) && slice[index] == target {
fmt.Printf("Элемент %d найден по индексу %dn", target, index)
} else {
fmt.Printf("Элемент %d не найденn", target)
}
}Вот и весь сказ, блядь. Не городи велосипед, используй готовое. А то напишешь свою реализацию, накосячишь где-нибудь в условии выхода, и будет тебе вечный цикл — хуй с горы, пока программа не накрылась медным тазом.