"Graham's scan is the most popular and fundamental method of finding the convex hull of a finite set of points with time complexity O(n log n)." - Wikipedia
1. Introduction
In this post, I will share my recent ideas of time complexity analysis for Graham scan algorithms that I've learned in CG class, as well as how it relates to the classical KMP algorithm.
As mentioned in the class, the scan process of the Graham scan algorithm can be done in linear time, and the trick in CG class is to construct a suitable linear combination of the size of the two stacks so that the changes in the different branches of the if-else statement are equal. Hence, the number of times the while loop is executed is tactfully converted to the times that A=S.size()+2*T.size() are decremented.
The above method to obtain the time complexity is definitely correct. But the meaning of the constructed A is not very clear. We thus want to explore whether we can find a solution that does not need the tricky variable A but can intuitively analyze the time complexity purely based on the Graham scan algorithm per se.
2. Identifying the counterpart using analogy
To find some starting points, we can refer to another algorithm that is very similar to the Graham scan algorithms, i.e., KMP for string matching:
2.1 Analyzing KMP time complexity
The key variable is q, q is initially 0, by the 9th line we can see that , q is increased by 1 each time, so in the loop from beginning to end, q is added by 1 for at most n times, by the 6th,7th line, q will be decremented by at least 1 in each loop of while.
Since the number of times q is incremented by 1 is at most n, q is initially zero, and in the end q is non-negative, so q is decremented for at most n times in the loop, therefore, the while statement is executed at most n times. Note that the number of times that the while statement is executed is exactly the number of times that the KMP algorithm loop will execute. Thus, the number of times of KMP loop is no more than n times and is clearly in linear time complexity.
2.2 The analogy comes in
Based on the analysis of KMP algorithm, we transfer it to Graham scan by analogy:
1) S.size () is analogous to q in KMP;
2) S.pop () is equivalent to q = q-1, analogous to the 6,7th line of KMP;
3) S.push () is equivalent to q = q + 1, analogous to the 8,9th line of KMP;
This naturally leads to the following three notes:
1) For each point, the number of times that it is pushed to S is exactly once.
This can be justified by referring to the S.push (T.pop ()) statement; all the points will be popped out and pushed to S; for S, the points once are popped, will not appear again.
2) In Graham scan, each time while looping, we perform either s.push (), or s.pop (), so the number of loop executions is the total number of times of S.push () + S.pop ()
3) S.size () is greater than or equal to 3 when the loop is ended (since the first, second and last points must be in S).
3. Conclusive remarks
So now it's easy to look at the time complexity of Graham scan:
1) S.push () executes n-2 times (because of the first note above, also note that the first and the second are pushed into S before the loop is executed);
2) S.pop () executes less than or equal to n-3 (due to the third note above);
3) The total number of times S.push () + S.pop () is less than or equal to n-2 + n-3 = 2n-5 times (exactly the same as the conclusion that appears in course-ware).
Therefore, we conclude that the scan process of the Graham scan has linear time complexity.
Above, we analyze how to compute time complexity of Graham scan algorithm. This is done by analogy: we use the inherent variable S.size() (analogous to q in KMP) for indicating the Graham scan time complexity.
If you identify any technical errors or confounding stuff, feel free to drop a comment
