Convex Hull | Monotone chain algorithm

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;

class Point {
    public int x;
    public int y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

class HelloWorld {

    // A utility function to return square
    // of distance between p1 and p2
    public static int distSq(Point p1, Point p2)
    {
        return (p1.x - p2.x) * (p1.x - p2.x)
            + (p1.y - p2.y) * (p1.y - p2.y);
    }

    // To find orientation of ordered triplet (p, q, r).
    // The function returns following values
    // 0 --> p, q and r are collinear
    // 1 --> Clockwise
    // 2 --> Counterclockwise
    public static int orientation(Point p, Point q, Point r)
    {
        int val = (q.y - p.y) * (r.x - q.x)
                  - (q.x - p.x) * (r.y - q.y);

        if (val == 0)
            return 0;
        else if (val > 0)
            return 1;
        else
            return 2;
    }

    // Prints convex hull of a set of n points.
    public static void printHull(List<Point> hull)
    {

        Console.WriteLine("The points in Convex Hull are:");
        for (int i = 0; i < hull.Count; i++) {
            Console.WriteLine("(" + hull[i].x + ", "
                              + hull[i].y + ")");
        }
    }

    // Prints convex hull of a set of n
    // points.
    public static void convexHull(List<Point> points, int n)
    {

        // There must be at least 3 points
        if (n < 3) {
            return;
        }

        // Initialize Result
        List<Point> hull = new List<Point>();

        // Find the leftmost point
        int l = 0;
        for (int i = 1; i < n; i++) {
            if (points[i].x < points[l].x) {
                l = i;
            }
        }

        // Start from leftmost point, keep
        // moving counterclockwise until
        // reach the start point again
        // This loop runs O(h) times where h is
        // number of points in result or output.
        int p = l;
        int q = 0;
        while (true) {

            // Add current point to result
            hull.Add(points[p]);

            // Search for a point 'q' such that
            // orientation(p, x, q) is counterclockwise
            // for all points 'x'. The idea is to keep
            // track of last visited most counterclock-
            // wise point in q. If any point 'i' is more
            // counterclock-wise than q, then update q.
            q = (p + 1) % n;

            for (int i = 0; i < n; i++) {

                // If i is more counterclockwise than
                // current q, then update q
                if (orientation(points[p], points[i],
                                points[q])
                    == 2) {
                    q = i;
                }
            }

            // Now q is the most counterclockwise with
            // respect to p. Set p as q for next iteration,
            // so that q is added to result 'hull'
            p = q;

            // While we don't come to first point
            if (p == l) {
                break;
            }
        }

        // Print Result
        printHull(hull);
    }

    static void Main()
    {
        List<Point> points = new List<Point>();

        points.Add(new Point(0, 3));
        points.Add(new Point(2, 2));
        points.Add(new Point(1, 1));
        points.Add(new Point(2, 1));
        points.Add(new Point(3, 0));
        points.Add(new Point(0, 0));
        points.Add(new Point(3, 3));

        int n = points.Count;
        convexHull(points, n);
    }
}

// The code is contributed by Nidhi goel.