Convex Hull Algorithm - Problem

Given a set of 2D points in the plane, find the convex hull of these points. The convex hull is the smallest convex polygon that contains all the given points.

A convex hull can be visualized as the shape formed by stretching a rubber band around all the points - the band will touch some points (which form the hull) and enclose all others.

Return the points that form the convex hull in counter-clockwise order, starting from the bottommost point (or leftmost if there are ties).

Input: An array of points where each point is represented as [x, y]

Output: Array of points forming the convex hull in counter-clockwise order

Input & Output

Example 1 — Basic Square with Interior Point

$ Input: points = [[1,1],[2,2],[2,0],[0,0],[1,0]]

› Output: [[0,0],[2,0],[2,2],[1,1]]

💡 Note: The convex hull excludes the interior point (1,0) and forms a quadrilateral with vertices at (0,0), (2,0), (2,2), and (1,1) in counter-clockwise order

Example 2 — Triangle

$ Input: points = [[0,3],[1,1],[2,2],[4,4],[0,0],[1,2],[3,1],[3,3]]

› Output: [[0,0],[4,4],[0,3]]

💡 Note: After removing interior points, the convex hull is a triangle with vertices (0,0), (4,4), (0,3)

Example 3 — All Points Collinear

$ Input: points = [[1,1],[2,2],[3,3]]

› Output: [[1,1],[3,3]]

💡 Note: When all points lie on a line, the convex hull consists of just the two endpoints

Constraints

1 ≤ points.length ≤ 3000
-50 ≤ points[i][0] ≤ 50
-50 ≤ points[i][1] ≤ 50
All points are unique

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to sort points lexicographically, then build separate lower and upper hull chains by maintaining only left turns (backtracking when right turns occur). Best approach is Andrew's Monotone Chain Algorithm with optimal Time: O(n log n), Space: O(n).

Common Approaches

✓ Andrew's Monotone Chain Algorithm

⏱️ Time: O(n log n) Space: O(n)

Sort all points by x-coordinate, then construct lower and upper convex chains separately by maintaining only left turns (backtracking when right turns occur).

Brute Force - Check All Combinations

⏱️ Time: O(n⁴) Space: O(n)

For each possible subset of 3 or more points, check if it forms a valid convex hull by verifying all other points are inside or on the boundary of this polygon.

Andrew's Monotone Chain Algorithm — Algorithm Steps

Sort points by x-coordinate (then by y-coordinate)
Build lower hull: scan left-to-right, maintain left turns only
Build upper hull: scan right-to-left, maintain left turns only
Combine lower and upper hulls to form complete convex hull

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Points

Sort by x-coordinate (then y-coordinate for ties)

Lower Hull

Scan left-to-right, maintain left turns, backtrack on right turns

Upper Hull

Scan right-to-left, maintain left turns, backtrack on right turns

Combine

Merge lower and upper chains to form complete convex hull

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int x, y;
} Point;

long long crossProduct(Point O, Point A, Point B) {
    return (long long)(A.x - O.x) * (B.y - O.y) - (long long)(A.y - O.y) * (B.x - O.x);
}

int comparePoints(const void* a, const void* b) {
    Point* pa = (Point*)a;
    Point* pb = (Point*)b;
    if (pa->x == pb->x) return pa->y - pb->y;
    return pa->x - pb->x;
}

int** solution(int** points, int pointsSize, int* returnSize, int** returnColumnSizes) {
    if (pointsSize <= 1) {
        *returnSize = pointsSize;
        *returnColumnSizes = (int*)malloc(pointsSize * sizeof(int));
        int** result = (int**)malloc(pointsSize * sizeof(int*));
        for (int i = 0; i < pointsSize; i++) {
            result[i] = (int*)malloc(2 * sizeof(int));
            result[i][0] = points[i][0];
            result[i][1] = points[i][1];
            (*returnColumnSizes)[i] = 2;
        }
        return result;
    }
    
    // Convert to Point array and sort
    Point* pts = (Point*)malloc(pointsSize * sizeof(Point));
    for (int i = 0; i < pointsSize; i++) {
        pts[i].x = points[i][0];
        pts[i].y = points[i][1];
    }
    qsort(pts, pointsSize, sizeof(Point), comparePoints);
    
    // Build lower hull
    Point* lower = (Point*)malloc(pointsSize * sizeof(Point));
    int lowerSize = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        while (lowerSize >= 2 && crossProduct(lower[lowerSize-2], lower[lowerSize-1], pts[i]) <= 0) {
            lowerSize--;
        }
        lower[lowerSize++] = pts[i];
    }
    
    // Build upper hull
    Point* upper = (Point*)malloc(pointsSize * sizeof(Point));
    int upperSize = 0;
    
    for (int i = pointsSize - 1; i >= 0; i--) {
        while (upperSize >= 2 && crossProduct(upper[upperSize-2], upper[upperSize-1], pts[i]) <= 0) {
            upperSize--;
        }
        upper[upperSize++] = pts[i];
    }
    
    // Combine hulls
    int hullSize = lowerSize - 1 + upperSize - 1;
    *returnSize = hullSize;
    *returnColumnSizes = (int*)malloc(hullSize * sizeof(int));
    int** result = (int**)malloc(hullSize * sizeof(int*));
    
    int idx = 0;
    for (int i = 0; i < lowerSize - 1; i++) {
        result[idx] = (int*)malloc(2 * sizeof(int));
        result[idx][0] = lower[i].x;
        result[idx][1] = lower[i].y;
        (*returnColumnSizes)[idx] = 2;
        idx++;
    }
    for (int i = 0; i < upperSize - 1; i++) {
        result[idx] = (int*)malloc(2 * sizeof(int));
        result[idx][0] = upper[i].x;
        result[idx][1] = upper[i].y;
        (*returnColumnSizes)[idx] = 2;
        idx++;
    }
    
    free(pts);
    free(lower);
    free(upper);
    
    return result;
}

int main() {
    // Simplified demo
    int points[5][2] = {{1,1}, {2,2}, {2,0}, {0,0}, {1,0}};
    int* pointsArray[5];
    for (int i = 0; i < 5; i++) {
        pointsArray[i] = points[i];
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(pointsArray, 5, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step, hull construction is O(n) as each point is processed at most twice

✓ Linear Growth

Space Complexity

O(n)

Space for sorted points array and hull result storage

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Convex Hull Algorithm - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Andrew's Monotone Chain Algorithm — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler