complexity of code

Question

what is the complexity of a program having only one loop, is it log n? can someone give me some ideas about estimating complexity of codes?

Answer 1

You can easily predict the computation time and complexity of your code with some tools such as "trend-prof"(https://pdfs.semanticscholar.org/8616/7f320e230641299754e0fbd860c44f5895f0.pdf)

For the same purpose on R codes, the GuessCompx library available in Github.

Answer 2

If there's just one loop, it's probably the number of times that loop's body executes.... But of course you may have many hidden loops in library calls. It's easy to make a loop that executes n times O(n^2) or worse if you have strlen, memcpy, etc. taking place inside the loop body.

Or even worse, if you have a library (or language) with regular expressions and their regex implementation is naive (like Perl), it's easy to make a program with just a single loop O(2^n)!! This cannot happen with a correctly written regex implementation.

Answer 3

Well, that really depends on what is going on in that loop.

This loop is linear time, i.e., O(n):

int sum = 0;
foreach( int i in SomeCollection )
{
    sum += i;
}

However, consider a loop which performs a substring search during each iteration. Now you have to consider the complexity of the string searching algorithm. Your question can't be answered as it stands. You will need to provide a code sample if you want a meaningful answer.

Answer 4

Software Complexity

There is a field of study that attempts to quantify exactly that.

It's called cyclomatic complexity.

In this case, I believe your complexity rating would be p = 2, because the loop is conditional and that means there are two paths through the method.

Time complexity

If you are referring to time complexity, it's still just O(1) unless the loop iteration count is derived via a polynomial or exponential function, perhaps indirectly because the method is itself called in a higher loop, or because the loop counter is effectively multiplied by string operations or something at a lower level.

Answer 5

To get the Big-O complexity of a piece of code, you need to ask yourself "how many iterations are done"?

The problem is of course, that it isn't always easy to figure it out from the code itself, sometimes it's just better to look at the big picture and calculate the amount of operations done.

Examples:

For (i = 0 ; i < n ; i++ ) {
   //Do stuff
}

This is a complexity

For (i = n ; i > 0 ; i= i/2 ) {
   //Do stuff
}

This is a complexity... Because in each iteration i is cut in half.

void Mess (int n) {
    for (i = 0 ; i < n ; i++) {
         //Do stuff
         Mess(n-1);
    } 
}

Now this looks like a simple loop, nut because it calls itself with recursion, it's actually quite a mess.... Each iteration calls itself n times with n-1.
So here it would be easier to think from the end. If n == 1 , there's 1 iteration. If n == 2 then it calls the previous scenario twice.
So if we'll call the function , we can see what we'll get this recursively: Which in the end will of course give us n!

Bottom line, it's not always trivial.

Answer 6

If it is Big-O time complexity you are asking about, then for loop it is n times complexity of whatever is within the loop, where n is loop count limit.

So. if the code inside loop is taking constant time to execute, i.e. if its time complexity is O(1), then the complexity of the loop will be O(1*n) = O(n).

In the similar way, if within the loop you have another loop which will make m steps, then your entire code is O(n*m), and so on.