Time complexity of function calling another function?

Question

I know how to find the time complexity for almost any option (simple function, function with loops, etc.), but I can't figure out how to determine time complexity of function that is calling another function, specifically if the calling function is inside a loop.

I wrote some functions, that I use as example.

int g(int k) {
  int i=0;

  while(k>0) {
    i += k;
    k= k/2;
  }

  return i;
}

int f(int n) {
  int m = 0;

  for (int i=0; i<n; ++i) {
    for (int j=i; j<n; ++j) {
      m += g(j);
    }
  }

  return m;
}

I can't figure out: do I have to consider the time complexity of function g(), and if I have to how to calculate it in function f()? Or do I just ignore function g() and include just the function calls in function f()?

Reazul Hasan Russel · Accepted Answer · 2016-06-30T21:49:22.843

5

As, the function g's complexity depends on the parameter k (logarithmic), you have to consider it while calling it from function f. In case, if g's worst case operation has constant time complexity, then you may not need to consider it explicitly.

In your case, f's complexity is O(n²) & g's complexity is O(lg(n)), yielding an overall complexity of O(n²lg(n))

edited Jun 30 '16 at 21:49

answered Jun 30 '16 at 21:22

Reazul Hasan Russel

164
1
5

2

f's complexitiy is O(n^2 ln(n)) it would be O(n^2) if g had constant complexity – 463035818_is_not_an_ai Jun 30 '16 at 21:44
Agree with tobi303, if function g had constant complexity, then the overall complexity would be O(n^2). – Reazul Hasan Russel Jun 30 '16 at 21:48
Then why do you write "f's complexity is O(n^2)" ? That is misleading. – 463035818_is_not_an_ai Jul 01 '16 at 08:23

score 2 · Answer 2 · answered Jun 30 '16 at 21:14

2

You have to take account complexity of g in f.

g has O(log(n)) complexity.

so complexity of f is the sum of those complexity log(j)s.

At worst it is O(n²log(n)).

answered Jun 30 '16 at 21:14

Jarod42

203,559
14
181
302

galinette · Answer 3 · 2016-06-30T21:50:17.843

In order to find the complexity of f, just inline the code of g inside f, and think as if this was a single whole function. The call himself is O(1) and thus has no impact on complexity, it's as if the code inside g was executed at the place where g is called.

This would be untrue in some cases, for instance if you pass by value an array of size n as a parameter to the function : in this case, the array copy itself would be O(n), so the call would have some effect on complexity.

score 1 · Answer 4 · answered Jul 04 '16 at 03:38

1

This is intuitively n²log(n), but more precisely, you get the following proof:

answered Jul 04 '16 at 03:38

Mohamed Ennahdi El Idrissi

2,931
2
19
32

Time complexity of function calling another function?

4 Answers4