Большой О, как вы рассчитываете/аппроксимируете это?

Big O дает верхнюю границу complexity временной сложности алгоритма. Обычно asymptotic-complexity он используется в сочетании performance с обработкой наборов данных complexity (списков), но может использоваться slow и в других местах.

Несколько optimisation примеров того, как это используется algorithms в коде C.

Допустим, у нас optimisation есть массив из n элементов

int array[n];

Если complexity бы мы хотели получить доступ algorithm к первому элементу массива, это performance было бы O(1), поскольку не optimisation имеет значения, насколько algorithms велик массив, для получения performance первого элемента всегда требуется algorithm одно и то же постоянное время.

x = array[0];

Если optimize мы хотим найти число в списке:

for(int i = 0; i < n; i++){
    if(array[i] == numToFind){ return i; }
}

Это complexity будет O(n), так как в лучшем complexity-theory случае нам придется просмотреть algorithm весь список, чтобы найти algorithm наш номер. Big-O по-прежнему slow равен O(n), даже если мы performance можем найти наше число с slow первой попытки и пройти цикл slow один раз, потому что Big-O performance описывает верхнюю границу slow алгоритма (омега — нижняя optimization граница, а тета — жесткая algorithms граница). .

Когда мы дойдем slow до вложенных циклов:

for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++){
        array[j] += 2;
    }
}

Это O(n^2), так algorithm как для каждого прохода внешнего big-o цикла ( O(n) ) мы должны algorithms снова пройти весь список, поэтому complexity n умножаются, оставляя n algorithms в квадрате.

Это едва поверхностно, но complexity-theory когда вы начинаете анализировать big-o более сложные алгоритмы, в complexity-theory игру вступает сложная математика, включающая big-theta доказательства. Надеюсь, это optimization познакомит вас хотя бы с algorithm-design основами.