Итак, вы узнали немного питона. Вы создали классное маленькое приложение Todo и несколько покупок. Но теперь пришло время предпринять следующие шаги в мир информатики, верно?
Big-O может выглядеть как сложная вещь, которую можно схватить, но так же было программированием для всех, кто впервые начал. Давайте посмотрим, что такое Big-O, прежде чем мы его разбили.
Изображение предоставлено Бигочеатшисты
Объясните Big-O, как мне пять
В прямом до места Биг-О рассказывает нам, как долго требуется алгоритм. Теперь я не имею в виду за секунды или миллисекунд. Я говорю о том, сколько итераций или операций это требуется. Что я имею в виду под этим? Давайте посмотрим на несколько примеров.
Здесь у нас есть метод печати, который в Big-O был бы O (1)
def hello_world():
print("Hello World!")
hello_world()
Вы можете видеть в простом методе печати, у нас потребовалась одна операция для печати Hello World. Если вы видите диаграмму выше, вы можете увидеть O (1) находится внизу, представляя его как самый быстрый метод в соответствии с сложностью Big-O. Это хорошо, верно? Абсолютно. Конечно, никто не заплатит нам разработчики, чтобы сделать печатные заявления весь день.
Вот еще один пример O (1)
def print_index_three(lists): print(lists[2]) # No matter how big our list, were still always calling index 3 print_index_three([1,2,3,4,5,6,7,8,9,10])
А как насчет следующего примера? Были на графике, вы догадаете, это подходит?
my_list = ["Apple", "Mango", "Pear", "Cherry", "Grape", "Orange",
"Blue Berry", "Papaya", "Melon", "Kiwi", "Banana"]
def find_fruit(lst, name)
for fruit in lst:
if fruit == name:
return True
find_fruit(my_list, "Orange")
Наш find_fruit Функция содержит для петля и Если утверждение. Возможно, вы думаете, что это две операции, но на самом деле это все еще одна операция. Который в Big-O, это O (1)
Представляем для Loop – это то, где наши операции начинают расти. Как мы можем видеть my_list имеет 11 фруктов. Таким образом, наша функция поиска передаст каждый элемент в списке 6 раз, чтобы найти Orange. Операции * 6 Анкет или в Big-O: На)
Что если элемент, который мы искали, был первым элементом в списке? Подумай об этом, было бы O (1) ? или На) Все еще? Это было бы O (1), потому что это была единственная операция, чтобы найти первый элемент. Это называется Лучший сценарий в Big-O.
Как насчет худший вариант развития событий Вам может быть интересно? Ну, это был бы последний элемент в мой список Как это потребует Большинство операции для завершения нашей функции поиска. Большая часть того, что делает теории Big-O, основана на Худший сценарий Анкет При работе с данными чаще, тогда не ваши программные конструкции должны будут иметь в виду масштаб. Всегда задайте себе этот вопрос, когда это возможно.
” Какой сценарий худшего случая? “
Более эффективный алгоритм поиска
Наша функция поиска будет отлично подойдет с несколькими элементами списка, но когда мы получим список из 100 000 предметов. Мы никогда не знаем, что были в списке нашего целевого элемента. Чтобы решить это, общий алгоритм – это Бинарный поиск .
def binary_search(lst, x):
low = 0
high = len(lst) - 1
mid = 0
while low <= high:
mid = (high + low) // 2
# Check if x is present at mid
if lst[mid] < x:
low = mid + 1
# If x is greater, ignore left half
elif lst[mid] > x:
high = mid - 1
# If x is smaller, ignore right half
else:
return mid
# If we reach here, then the element was not present
return -1
ordered_list = [1, 8, 13, 22, 31, 76, 79, 84, 92, 99]
# ^
# middle split
# Lets search for 79
print(binary_search(ordered_list, 79))
Не очень часто инженеры программного обеспечения могут играть с отсортированными данными, но если вы знаете, что это будет, двоичный поиск – лучший выбор для вопроса, Какой сценарий наихудшего случая?
Бинарный поиск подпадает под O (log n) на диаграмме сложности Big-O. Если вы уже знаете, что такое логарифмы, то я уверен, что вы понимаете, почему. Бинарный поиск примет наибольший индекс списка и разделил его прямо в середине. Затем запустите O (1) Операция, где он проверяет, является ли элемент, который вы ищете, меньше, чем текущий средний индекс. Если это не проигнорирует левую половину, найдите новый средний индекс, а затем повторите процесс, пока не найдет наш индекс элементов.
Из примера примера кода наша цель 79. Сколько раз наш алгоритм будет повторяться над разделением списка? Это займет 3 операции. Давая нам наши журнал n Если вы решите использовать бинарный поиск в ближайшем будущем, имейте в виду, что его эффективность повышается, больше индексов в списке.
Давайте посмотрим на более сложный пример
Теперь, если вы со мной до сих пор можете увидеть различные сложности Big-O ( o (n) , o (1) , o (log n)) Не так уж плохо, чтобы понять. Существуют простые математические идеи, представляющие, насколько сложны алгоритм или функция.
Давайте посмотрим на фактический алгоритм в действии и шоу, который он принадлежит.
Один из первых алгоритмов вида вида, который вы узнаете, – это Merge-Sort Анкет Короче говоря, он разбивает список пополам, а затем неоднократно расщепляет эти списки, вызывая себя рекурсивно, а затем сравнивает их, когда он объединяет список обратно. Смотрите Здесь или это видео Больше подробностей. Если вы еще не уверены, что такое рекурсия, см. Здесь Анкет
def merge_sort(lst):
if len(lst) >1:
mid = len(lst) // 2 # The Middle of the list
Left = lst[:mid]
Right = lst[mid:]
# As each list splits, you split those lists again. (Recursion)
merge_sort(Left)
merge_sort(Right)
i = 0
j = 0
k = 0
while i < len(Left) and j < len(Right):
if Left[i] < Right[j]:
lst[k] = Left[i]
i += 1
else:
lst[k] = Right[j]
j += 1
k += 1
# Check if any element was left.
while i < len(Left):
lst[k] = Left[i]
i += 1
k += 1
while j < len(Right):
lst[k] = Right[j]
j += 1
k += 1
my_list = [156, 42, 3, 78, 45, 22, 98, 100]
merge_sort(my_list)
print(my_list)
Если вы впервые увидите слияние, это может показаться немного сложным, но на самом деле это не так. В Big-O слияние падает под O (n log n) который в значительной степени находится в середине времени, как долго алгоритм может занять алгоритм.
Что делает это O (n log n) ? Если мы разбиваем это выражение в математических терминах, оно довольно легко понять. Операции * (elements log (элементы)))) В приведенном выше примере у нас есть 8 элементов в списке. Что означает, что список разделился в половину 3 раза. Это наш log (n) . После разделения 3 раза мы получим 8 отдельных элементов для сравнения. Это наш не
После того, как все элементы находятся на их базе (список единичных элементов), затем они отсортируют обратно в 2 сортированных списка (слева и справа). Теперь это становится O (n) часть нашего O (n log n) , Помните наш пример выше, используя На) ? То же самое происходит здесь, за исключением того, что сравнивали, какое число является самым низким. Затем добавьте его в основной отсортированный список, который мы возвращаем.
Другая половина спектра
Там гораздо больше, чем я упомянул здесь. У тебя O (n^2) , O (2^n) и даже На!) . Но я хотел сохранить это краткое изложение. В будущем я буду преодолевать гораздо большие сложности, так как это первый из многих постов о Big-O. Знаете ли вы, что у всех уравнений Big-O также есть и их сложность? Вы можете узнать, насколько эффективна память, ваши алгоритмы тоже! Если вы заинтересованы в алгоритмах и структурах данных, я тоже буду публиковать об этом.
Дополнительные ресурсы, которые стоит проверить: https://www.bigocheatsheet.com/
Свяжитесь со мной! LinkedIn Twitter GitHub
Оригинал: “https://dev.to/syriiadvent/let-s-learn-the-big-o-h9e”