Итак, задайте следующую программу:
Является ли временная сложность этой программы O (0)? Другими словами, 0 0 (0)?
Я думал, что ответ на этот вопрос в отдельном вопросе пролить свет на этот вопрос.
EDIT: здесь есть много хороших ответов! Мы все согласны с тем, что 0 есть O (1). Вопрос в том, 0 0 (0) также?
От Wikipedia:
Описание функции в терминах большой записи O обычно дает только верхнюю оценку скорости роста функции.
Из этого описания, поскольку для пустого алгоритма требуется 0 времени для выполнения, он имеет верхнюю оценку O (0). Это означает, что это также O (1), которая оказывается большей верхней границей.
Изменить
Более формально из CLR (1ed, pg 26):
Для данной функции g (n) обозначим O ( g ( n)) множество функций
O (g ( n)) = { f ( n): существуют положительные константы c и n 0 такие, что 0 & le; f (n) & le; cg ( n) для всех n & ge; n 0}
Асимптотическая временная производительность пустого алгоритма, выполняемая за 0 раз независимо от ввода, поэтому является членом O (0).
Изменить 2:
Мы все согласны с тем, что 0 есть O (1). Вопрос в том, 0 0 (0) также?
Основываясь на определениях, я говорю "да".
Кроме того, я думаю, что в этом вопросе гораздо важнее, чем многие ответы. По сути, пустой алгоритм, вероятно, бессмыслен. Однако, когда задан нетривиальный алгоритм, пустой алгоритм можно рассматривать как лежащий между последовательными шагами заданного алгоритма, а также до и после шагов алгоритма. Приятно знать, что "ничто" не влияет на производительность асимптотического алгоритма.
Изменить 3:
Adam Crume делает следующее заявку:
Для любой функции f (x), f ( x) находится в O ( е ( х)).
Доказательство: пусть S - подмножество R и T - подмножество R * (неотрицательные действительные числа) и f (x): S → T и c & ge; 1. Тогда 0 & le; f ( x) & le; f ( x), что приводит к 0 & le; f ( x) & le; cf ( x) для всех x∈ S. Поэтому f ( x) ∈ O ( f ( x)).
В частности, если f (x) = 0, то f ( x) ∈ O (0).
Требуется столько же времени для запуска, независимо от ввода, поэтому по определению это O (1).
В нескольких ответах говорят, что сложность O (1), поскольку время является константой, а время ограничено произведением некоторого коэффициента и 1. Ну, верно, что время является константой и оно ограничено тем, что но это не означает, что лучшим ответом является O (1).
Рассмотрим алгоритм, который выполняется в линейном времени. Он обычно обозначается как O (n), но позволяет играть в защитника дьявола. Время ограничено произведением некоторого коэффициента и п ^ 2. Если мы считаем, что O (n ^ 2) является множеством, то множество всех алгоритмов, сложность которых достаточно мала, тогда в этом наборе лежат линейные алгоритмы. Но это не означает, что лучшим ответом является O (n ^ 2).
Пустой алгоритм находится в O (n ^ 2) и в O (n) и в O (1) и в O (0). Я голосую за O (0).
У меня есть очень простой аргумент для того, чтобы пустой алгоритм был O (0): для любой функции f (x) f (x) находится в O (f (x)). Просто пусть f (x) = 0, и мы имеем, что 0 (время выполнения пустого алгоритма) находится в O (0).
На стороне примечания, я ненавижу, когда люди пишут f (x) = O (g (x)), когда это должно быть f (x) ∈ O (g (x)).
Big O - асимптотическая нотация. Чтобы использовать большой O, вам нужна функция - другими словами, выражение должно быть параметризовано n, даже если n не используется. Нет смысла говорить, что число 5 равно O (n), то постоянная функция f (n) = 5 равна O (n).
Итак, чтобы проанализировать сложность времени в терминах большой O, вам нужна функция n. Ваш алгоритм всегда делает возможным 0 шагов, но без переменного параметра, говорящего об асимптотическом поведении, нет смысла. Предположим, что ваш алгоритм параметризуется n. Только теперь вы можете использовать асимптотическое обозначение. Нет смысла говорить, что это O (n 2) или даже O (1), если вы не укажете, что такое n (или переменная, скрытая в O (1))!
Как только вы остановитесь на количестве шагов, это вопрос определения большой O: функция f (n) = 0 равна O (0).
Так как это вопрос низкого уровня, это зависит от модели вычисления.
В "идеалистических" предположениях вы можете ничего не делать.
Но в Python вы не можете сказать def f(x):, но только def f(x): pass. Если вы считаете, что каждая команда, даже pass (NOP), занимает время, то сложность f (n) = c для некоторой константы c, и если c != 0 вы не можете сказать, что f есть O (1), а не O (0).
Стоит отметить, что большой O сам по себе не имеет ничего общего с алгоритмами. Например, вы можете сказать, что sin x = x + O (x 3) при обсуждении разложения Тейлора. Кроме того, O (1) не означает константу, это означает ограниченность константой.
Все ответы до сих пор затрагивают вопрос, как будто есть правильный и неправильный ответ. Но нет. Вопрос - вопрос определения. Обычно в теории сложности стоимость времени является целым числом, хотя это тоже просто определение. Вы можете сказать, что пустой алгоритм, который немедленно завершает работу, принимает 0 временных шагов или 1 временной шаг. Это абстрактный вопрос, потому что временная сложность - это абстрактное определение. В реальном мире у вас даже нет временных шагов, у вас есть непрерывное физическое время; может случиться так, что один процессор имеет такты синхронизации, но параллельный компьютер может легко иметь асинхронные часы, и в любом случае тактовый цикл очень мал.
Тем не менее, я бы сказал, что разумнее сказать, что операция остановки занимает 1 временной шаг, а не то, что требуется 0 временных шагов. Это кажется более реалистичным. Для многих ситуаций это, пожалуй, очень консервативно, потому что накладные расходы на инициализацию обычно намного больше, чем выполнение одной арифметической или логической операции. Предоставление пустого алгоритма 0 временных шагов было бы разумно моделировать, например, вызов функции, который удаляется оптимизирующим компилятором, который знает, что функция ничего не сделает.
Это должно быть O (1). Коэффициент всегда равен 1.
Рассмотрим:
Если что-то растет как 5n, вы не говорите O (5n), вы говорите O (n) [другими словами, O (1n)]
Если что-то растет, как 7n ^ 2, вы не говорите O (7n ^ 2), вы говорите O (n ^ 2) [другими словами, O (1n ^ 2)]
Аналогично вам следует сказать O (1), а не O (некоторая другая константа)
Нет такой вещи, как O(0). Даже машине oracle или гиперкомпьютеру требуется время для одной операции, то есть solve(the_goldbach_conjecture), ergo:
Все машины, теоретические или реальные, конечные или бесконечные производственные алгоритмы с минимальной сложностью времени O(1).
Но опять же, этот код здесь O(0):
// Hello world!
:)
Я бы сказал, что это O (1) по определению, но O (0), если вы хотите получить техническую информацию о нем: поскольку O (k 1 g (n)) эквивалентно O ( k 2 g (n)) для любых констант k 1 и k 2, то O (1 * 1) эквивалентно O (0 * 1), и поэтому O (0) эквивалентно O (1).
Однако пустой алгоритм не похож, например, на функцию идентификации, определение которой является чем-то вроде "return your input". Пустой алгоритм больше похож на пустой оператор или что-то еще происходит между двумя операторами. Его определение "абсолютно ничего не делает с вашим вводом", по-видимому, даже без подразумеваемых накладных расходов просто с вводом.
Следовательно, сложность пустого алгоритма уникальна тем, что O (0) имеет сложность нулевого времени, независимо от того, какая функция поражает вашу фантазию или просто равна нулю. Из этого следует, что поскольку весь бизнес настолько дурацкий, и поскольку O (0) уже не означает ничего полезного, и, поскольку он немного смехотворен, чтобы даже обсуждать такие вещи, разумный частный случай для O (0) выглядит примерно так:
Сложность пустого алгоритма O (0) во времени и пространстве. Алгоритм с временной сложностью O (0) эквивалентен пустому алгоритму.
Итак, вы идете.
Учитывая формальное определение Big O:
Пусть f (x) и g (x) - две функции, определенные над множеством действительных чисел. Тогда мы пишем:
f(x) = O(g(x)), когда x приближается к бесконечности, если существует вещественное M и вещественное x0, так что:
|f(x)| <= M * |g(x)| for every x > x0
Как я вижу, если подставить g (x) = 0 (для того чтобы иметь программу со сложностью O (0)), мы должны иметь:
|f(x)| <= 0, для каждого x > x0 (ограничение существования вещественного M и x0 практически снимается здесь)
что может быть истинным только тогда, когда f (x) = 0.
Итак, я бы сказал, что не только пустая программа O (0), но и единственная, для которой это выполняется. Интуитивно это должно было быть истинным, поскольку O (1) включает в себя все алгоритмы, требующие постоянного количества шагов независимо от размера его задачи, включая 0. По сути, бесполезно говорить о O (0); это уже в O (1). Я подозреваю, что это чисто из простоты определения, что мы используем O(1), где он также может быть O(c) или что-то подобное.
0 = O (f) для всей функции f, так как 0 <= | f |, поэтому также O (0).
O (1) означает, что временная сложность алгоритма всегда постоянна.
Скажем, у нас есть этот алгоритм (в C):
void doSomething(int[] n)
{
int x = n[0]; // This line is accessing an array position, so it is time consuming.
int y = n[1]; // Same here.
return x + y;
}
Я игнорирую тот факт, что массив может иметь меньше двух позиций, просто чтобы это было просто.
Если мы подсчитаем 2 наиболее дорогие линии, у нас будет общее время 2.
2 = O (1), потому что:
2 <= c * 1, если c = 2, для каждого n > 1
Если у нас есть этот код:
public void doNothing(){}
И мы считаем его имеющим 0 экспансивных линий, нет разницы в том, что он имеет O (0) O (1) или O (1000), потому что для каждой из этих функций мы можем доказать ту же теорему.
Обычно, если алгоритм берет на себя постоянное количество шагов для завершения, мы говорим, что он имеет временную сложность O (1).
Я предполагаю, что это просто соглашение, потому что вы можете использовать любое постоянное число для представления функции внутри O().
Нет. Это O (c), если вы не имеете зависимости от размера ввода, где c - любая положительная константа (обычно используется 1 - O (1) = O (12.37)).