Эффективность или сложность
Алгоритм находится, на простом английском, просто серия шагов для решения проблемы.
Решение проблем касается творчества, как подойти к проблеме с надлежащим решением.
Некоторые решения могут быть легко придумывать, но они не эффективны, то есть сложность выше, чем она должна быть.
Когда я говорю эффективным, вы можете подумать об этом в двух измерениях: пространство и время.
Размер времени состоит в том, как долго ваше решение требует, чтобы решить проблему
Размер пространства состоит в том, сколько хранения вашего решения потребляет решение проблемы.
В конце концов, оба размера объединяются к одной цели: лучше использовать ограниченные ресурсы.
Ваш компьютер имеет некоторое количество процессора, оперативной памяти и хранения, вам нужно выполнить работу, учитывая эти ограничения.
Наличие хорошей общите алгоритмов и структур данных много помогает в достижении этого.
Выбор правильной структуры данных и правый алгоритм помогает сохранить множество ресурсов при решении проблемы быстрее.
Большая O обозначение
Допустим, два человека пишут каждое одно и то же решение для данной проблемы.
Как вы можете сказать, какой из них лучше?
Для этого вы можете использовать Большая O обозначение , также известный как На) .
n Подпитывается для ввода вашего алгоритма к вашей функции.
Если вам нужно сделать некоторые вычисления на 10 записей, ваш n 10, так n это длина ввода.
Конечно, если вам придется иметь дело с 10 или 1 миллионами записями, то же самое решение может быть оптимально для обоих случаев, поскольку вы можете заметить, что что-то хорошо работает с небольшими объемами данных, не допускается большим количеством данных.
О Стенды для математической функции ввода n Точно так же, как мы определяем классику f (x) в математике.
Приближение
Сложность часто считается как худший сценарий.
Это означает, что, учитывая проблему с 10 записями, ваша программа должна будет включать в себя все 10, чтобы найти необходимую информацию.
Существует также ситуация, когда первая запись – это тот, который вы хотите, называемый лучшим случаем, и, наконец, существует средний случай, который будет 5, если мы работаем с 10 записями.
Используйте приближения и экстраполяции при работе со сложностью и большим обозначением.
Случаи O (n + 2) , O (2n + 20) , O (3n + 200) все могут быть аппроксимированы до O (n) Отказ
Возьмите этот пример, каждая строка – это вычисление, как показано в комментариях кода ниже.
Каждая строка в для Количество петлей, как n Потому что они делают вычисления на входе, поэтому сложность в для блок пропорционален входу.
С другой стороны, х и Вернуть х Считать как только 1, они выполняются только один раз.
def myFunction(n):
x = 0 #1
for i in n: #n
y =2*i #n
x += y #n
return x #1
print(myFunction([1,2,3]))
#output: 12
Подсчет количества n и 1 в функции сложность примера выше – O (3n + 2) .
Некоторые люди не считают линию с для Сама, в этом случае сложность была бы O (2n + 2) Отказ
В обоих случаях независимо от того, применяя правило приближения, это упрощает На) Поскольку постоянные кратные или простые дополнения констант не имеют значения для Общее темпы роста функции.
В этом примере у нас есть Линейный Темпы роста, это то, что имеет значение в конце.
Практическое понимание
Я описал причины, по которым вы должны беспокоиться о том, какие алгоритмы и структуру данных на выбор и обозначения, используемые в качестве общего языка для описания эффективности и сложности.
В этом разделе давайте посмотрим некоторые фрагменты кода и рассчитаем их сложность с нотацией большого o.
Пример 1: O (1)
Первый пример относится к Константа темпы роста.
Обратите внимание, что функция первый автомобиль () Лишь печатает свойства первого элемента/словаря в списке, просто простой вид.
Каждая команда печати доступа к одному свойству относится к одному, поэтому у нас есть O (5) И из-за принципа приближения конечная сложность этой функции проста O (1) Отказ
bmw = {
"name": "BMW 320i",
"torque": "550 Nm",
"year": 2019,
"top_speed": "280 km",
"cylinder_capacity": "1998 cc"
}
ferrari = {
"name": "Ferrari F8",
"torque": "770 Nm",
"year": 2020,
"top_speed": "340 km",
"cylinder_capacity": "3902 cc"
}
mclaren = {
"name": "McLaren 720S",
"torque": "770 Nm",
"year": 2017,
"top_speed": "341 km",
"cylinder_capacity": "3994 cc"
}
cars = [bmw, ferrari, mclaren]
def firstCar(cars):
print(cars[0]['name']) #1
print(cars[0]['torque']) #1
print(cars[0]['year']) #1
print(cars[0]['top_speed']) #1
print(cars[0]['cylinder_capacity']) #1
firstCar(cars)
#output:
#BMW 320i
#550 Nm
#2019
#280 km
#1998 cc
Пример 2: O (n)
Это тот, который я обсуждал раньше, Линейный темпы роста.
Мы повторяем каждый элемент списка и распечатайте свойство Имя Так как итерация находится над n Предметы в списке, это дает нам На) .
bmw = {
"name": "BMW 320i",
"torque": "300 Nm",
"year": 2019,
"top_speed": "280 km",
"cylinder_capacity": "1998 cc"
}
ferrari = {
"name": "Ferrari F8",
"torque": "770 Nm",
"year": 2020,
"top_speed": "340 km",
"cylinder_capacity": "3902 cc"
}
mclaren = {
"name": "McLaren 720S",
"torque": "770 Nm",
"year": 2017,
"top_speed": "341 km",
"cylinder_capacity": "3994 cc"
}
cars = [bmw, ferrari, mclaren]
def carNames(cars):
for car in cars: #n
print(car['name'])
carNames(cars)
#output:
#BMW 320i
#Ferrari F8
#McLaren 720S
Пример 3: O (нм)
В этом кодеском фрагменте у нас два вложенных для петли.
Первый цикл, итерат над предметами, n , списка, в то время как второй цикл итерации по свойствам, м из каждого предмета.
Таким образом, сложность – это количество предметов раз количество свойств, таким образом O (нм) Отказ
bmw = {
"name": "BMW 320i",
"torque": "300 Nm",
"year": 2019,
"top_speed": "280 km",
"cylinder_capacity": "1998 cc"
}
ferrari = {
"name": "Ferrari F8",
"torque": "770 Nm",
"year": 2020,
"top_speed": "340 km",
"cylinder_capacity": "3902 cc"
}
mclaren = {
"name": "McLaren 720S",
"torque": "770 Nm",
"year": 2017,
"top_speed": "341 km",
"cylinder_capacity": "3994 cc"
}
cars = [bmw, ferrari, mclaren]
def carSpecs(cars):
for car in cars: #n
for spec in car: #m
print(spec, ": ", car[spec])
carSpecs(cars)
#output:
#name : BMW 320i
#torque : 300 Nm
#year : 2019
#top_speed : 280 km
#cylinder_capacity : 1998 cc
#name : Ferrari F8
#torque : 770 Nm
#year : 2020
#top_speed : 340 km
#cylinder_capacity : 3902 cc
#name : McLaren 720S
#torque : 770 Nm
#year : 2017
#top_speed : 341 km
#cylinder_capacity : 3994 cc
Пример 4: O (n ^ 2)
Как и последний пример, у нас есть два вложенных для петли здесь, но На этот раз каждый цикл итерации за один и тот же список предметов n Отказ
Для каждой машины я сравниваю его с каждой другой машиной.
Сложность – это количество предметов в первом раковинам времени количество предметов во втором цикле, таким образом O (NN) или просто O (n ^ 2) , также известный как квадратичный темпы роста.
bmw = {
"name": "BMW 320i",
"torque": "300 Nm",
"year": 2019,
"top_speed": "280 km",
"cylinder_capacity": "1998 cc"
}
ferrari = {
"name": "Ferrari F8",
"torque": "770 Nm",
"year": 2020,
"top_speed": "340 km",
"cylinder_capacity": "3902 cc"
}
mclaren = {
"name": "McLaren 720S",
"torque": "770 Nm",
"year": 2017,
"top_speed": "341 km",
"cylinder_capacity": "3994 cc"
}
cars = [bmw, ferrari, mclaren]
def fasterCar(cars):
faster_car = {}
for car1 in cars: #n
for car2 in cars: #n
if car1['top_speed'] > car2['top_speed']:
faster_car = car1
else:
faster_car = car2
return faster_car
print(fasterCar(cars))
#{'name': 'McLaren 720S', 'torque': '770 Nm', 'year': 2017, 'top_speed': '341 km', 'cylinder_capacity': '3994 cc'}
Заключение
Это было первое введение в сложность и большую нотацию O, в будущих постах, обсуждающих различные алгоритмы и структуры данных, я проанализирую многие другие типы темпов роста.
Первоначально опубликовано в https://renanmf.com/4-examples-algorithmic-comexity-big-o-oationation/
Оригинал: “https://dev.to/renanmouraf/4-examples-in-python-to-understand-algorithmic-complexity-and-big-o-notation-32d0”