Another Convex Hull Algorithms

• This is not in Levitin
• But I like it.
• Graham Scan
  • See Wikipedia for a reference.
  • Or CLRS
  • We will assume WLOG that there are at least three non-colinear points.
  • The big idea
    1. Find the lowest leftmost point (lowest first, leftmost second).
    2. Sort the remaining points by polar angle.
    3. Travel around the points, keeping only those that make a right hand turn.
  • Consider
  • Point (23,4) is the lowest so start with that.
    • How long will it take to find this?
  • Now find the polar angle for each other point with the segment (24,4), (100,4)
  • And sort the points based upon this angle.
    • 
    • How long will this take?
  • Now look at the angle formed by p₀, p₁ and p₂
    • 
    • This is a left hand turn (driving p₀, p₁) then turning onto ( p₁ and p₂)
    • The candidate hull (H) is {p₀, p₁, p₂}
  • Do the same for the angle formed by p₁, p₂ and p₃
    • 
    • Again it is a left hand turn so keep it.
    • H = {p₀, p₁, p₂, p₃}
  • Do the same for the angle formed by p₂, p₃ and p₄
    • 
    • It is not a left hand turn, so reject point 3
    • and now check the angle formed by p₁, p₂ and p₄
    • H = {p₀, p₁, p₂, p₄}
  • For p₅
    • 
    • H = {p₀, p₁, p₂, p₅}
  • For p₆
    • 
    • H = {p₀, p₁, p₂, p₆}
  • For p₇
    • 
    • H = {p₀, p₁, p₂, p₇}
  • For p₈
    • 
    • H = {p₀, p₁, p₂, p₇, p₈}
  • And the rest
    • 
    • H = {p₀, p₁, p₂, p₇,p₉, p₁₁}
• The Algorithm:

  GRAHAM_SCAN(P)
  
   Let p0 be the point in P with the minimum y-coordinate, select the leftmost in the case of a tie.
   Sort the remaining points by polar angle with p0
   S.push(p0)
   S.push(p1)
   S.push(p2)
   for i ← 3 to n do 
        while the angle formed by S.top(), S.next_to_top() and pi make a nonleft turn
            S.pop()
        S.push(pi)
   return S
  
      

• Is this the algorithm?
• What is best case performance?
• What is the worst case performance?
• Are we sure that it works?
• What is the space complexity?