What counts as an operation in algorithms?-CodePudding

So I've just started learning algorithms and data structures, and I've read about Big O and how it portrays complexity of algorithms based on how the number of operations required scales

But what actually counts as an operation? In this bubble sort, does each iteration of the for loop count as an operation, or only when an if statement is triggered, or all of them?

And since there are so many different algorithms of all kinds, how do you immediately identify what would count as an "operation" happening in the algorithm's code?

function bubbleSort(array) {
    for (let i = 0; i < array.length; i  ) {
        for (let j = 0; j < array.length; j  ) {
            if (array[j   1] < array[j]) {
                let tmp = array[j]
                array[j] = array[j 1]
                array[j 1] = tmp
            }
        }
    }
    return array
}

CodePudding user response：

You can count anything as an operation that will execute within a constant amount of time, independent of input. In other words, operations that have a constant time complexity.

If we assume your input consists of fixed-size integers (like 32-bit, 64 bit), then all of the following can be considered such elementary operations:

i  
j < array.length
array[j   1] < array[j]
let tmp = array[j]
...

But that also means you can take several of such operations together and still consider them an elementary operation. So this is also an elementary operation:

if (array[j   1] < array[j]) {
    let tmp = array[j]
    array[j] = array[j 1]
    array[j 1] = tmp
}

So, don't concentrate on breaking down operations into smaller operations, and those again into even smaller operations, when you are already certain that the larger operation is O(1).

CodePudding user response：

Usually, everything that happens is a single operation. This is one of the reason we don't actually count the exact number of them, but instead use asymptotic notations (big O and big Theta).

However, sometimes you are interested about one kind of operation only. A common example is algorithms that use IO. Since IO is significantly more time consuming than anything happening on the CPU, you often just "count" the number of IO operations instead. In these cases, you often actually care about exact number of times an IO occurs, and can't use only asymptotic notations.