Алгоритм Грэхема

#include <iostream>
#include<cmath>
#include<stack>
#include<vector>
#include<fstream>
using namespace std;
const double PI = 3.14159265;
//============================================//
 
struct hull
{
    double x;
    double y;
};
 
int Lowest_point(hull *value, const int n)
{
    int k = 0;
    for (int i = 1; i < n; i++)
    {
        if (value[i].y < value->y)
        {
             k = i;
        }
 
    }
    return k;
}
 
void Angle(vector<double>& ps2, hull* point, const int n)
{
    
    ps2.resize(n);
    int j = Lowest_point(point, n);
    for (int i = 0; i < n; i++)
        ps2[i] = atan2(point[i].y - point[j].y, point[i].x - point[j].x) * 180 / PI;
 
    for (int i = 0; i < n; i++)
        cout << ps2[i] << endl;
}
 
void Sort(vector<double> &a, hull *b, const int n)
{
 
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (a[j] > a[i])
            {
                swap(a[i], a[j]);
                swap(b[i], b[j]);
            }
        }
    }
}
 
double result(const hull &p1, const hull &p2, const hull &p3)
{
    return (p2.x - p1.x)*(p3.y - p1.y) - (p3.x - p1.x)*(p2.y - p1.y);
}
 
bool leftTurn(const hull &a, const hull &b, const hull &c)
{
    return result(a, b, c) > 0;
}
 
void Stack(vector<double> &ang, hull *point)
{
    stack<int>S;
    S.push(0);
    S.push(1);
 
    for (int c = 2; c < ang.size(); c++)
    {
        int a, b;
        do
        {
            b = S.top();
            S.pop();
            a = S.top();
        }
 
        while (!leftTurn(point[a], point[b], point[c]));
 
        S.push(b);
        S.push(c);
    }
 
    cout << endl;
    while (!S.empty())
    {
        cout << point[S.top()].x << " " << point[S.top()].y << endl;
        S.pop();
    }
}
 
 
int main()
{
    ifstream inFile;
    inFile.open("point.txt");
 
    if (!inFile.is_open())
    {
        cout << "Could not open the file! ";
        system("pause");
        exit(EXIT_FAILURE);
    }
 
    int N;
    inFile >> N;
 
    hull *ps = new hull[N];
 
    int i = 0;
    while (i < N && inFile.good())
    {
        inFile >> ps[i].x >> ps[i].y;
        ++i;
    }
    vector<double>ps2;
 
    Angle(ps2, ps, N);
    Sort(ps2, ps, N);
    Stack(ps2, ps);
 
    delete[] ps;
    system("pause");
    return 0;
}