123123

.h
#pragma once

struct Point
{
int x;
int y;
};


class alg
{
public:
alg();
~alg();

//void set_m(int);
//int get_m();


// A utility function to find next to top in a stack
Point nextToTop();

// A utility function to swap two points
void swap(Point, Point);

// A utility function to return square of distance between p1 and p2
int dist(Point, Point);

int orientation(Point, Point, Point);

// A function used by library function qsort() to sort an array of
// points with respect to the first point
int compare(const void, const void );

// Prints convex hull of a set of n points.
void convexHull(Point[] , int );

};

cpp
#include "StdAfx.h"
#include "alg.h"
#include <stack>
#include <stdlib.h>
#include<math.h>
#include <iostream>

using namespace std;
using namespace System;

Point p0;
alg::alg()
{
}

alg::~alg()
{
}

Point nextToTop(stack<Point> &S)
{
Point p = S.top();
S.pop();
Point res = S.top();
S.push(p);
return res;
}

void swap(Point &p1, Point &p2)
{
Point temp = p1;
p1 = p2;
p2 = temp;
}

int dist(Point p1, Point p2)
{
return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}

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; // colinear
return (val > 0) ? 1 : 2; // clock or counterclock wise
}

// A function used by library function qsort() to sort an array of
// points with respect to the first point
int compare(const void *vp1, const void *vp2)
{
Point *p1 = (Point *) vp1;
Point *p2 = (Point *) vp2;

// Find orientation
int o = orientation(p0, *p1, *p2);
if (o == 0)
return (dist(p0, *p2) >= dist(p0, *p1)) ? -1 : 1;

return (o == 2) ? -1 : 1;
}

// Prints convex hull of a set of n points.
void convexHull(Point points[], int n)
{
// Find the bottommost point
int ymin = points[0].y, min = 0;
for (int i = 1; i < n; i++)
{
int y = points[i].y;

// Pick the bottom-most or chose the left most point in case of tie
if ((y < ymin) || (ymin == y && points[i].x < points[min].x))
ymin = points[i].y, min = i;
}

// Place the bottom-most point at first position
swap(points[0], points[min]);

// Sort n-1 points with respect to the first point. A point p1 comes
// before p2 in sorted ouput if p2 has larger polar angle (in
// counterclockwise direction) than p1
p0 = points[0];
qsort(&points[1], n - 1, sizeof(Point), compare);

// Create an empty stack and push first three points to it.
stack<Point> S;
S.push(points[0]);
S.push(points[1]);
S.push(points[2]);

// Process remaining n-3 points
for (int i = 3; i < n; i++)
{
// Keep removing top while the angle formed by points next-to-top,
// top, and points[i] makes a non-left turn
while (orientation(nextToTop(S), S.top(), points[i]) != 2)
S.pop();
S.push(points[i]);
}

// Now stack has the output points, print contents of stack
while (!S.empty())
{
Point p = S.top();
cout « "(" « p.x « ", " « p.y « ")" « endl;
S.pop();
}
}


main
#include "StdAfx.h"
#include <iostream>
#include <stack>
#include <stdlib.h>
#include "fstream"
#include "alg.h"
#include <math.h>

using namespace System;
using namespace System::IO;
using namespace std;

int main()
{
alg gr;

ifstream fin("d:\resC.txt", ios::binary);
int n=10;
char buffer[512];

int a[2][512]={};

fin.read(buffer, n*2); // считали n байт
int j=0;
for(int i=0;i<n;i++)
{
a[0][i]= (int)buffer[j];
a[1][i]=(int)buffer[j+1];
j=j+2;
}
int p=0;
for(int i=0;i<n;i++)
{
cout«a[0][i]«"#";
cout«a[1][i]«" "«endl;
p=p+2;
}
Point points[256];
for (int i=0;i<n;i++)
{
points[i].x= a[0][i];
points[i].y= a[1][i];

}

int k = sizeof(points) / sizeof(points[0]);
cout « "The points in the convex hull are: \n";

gr.convexHull(points, n);
system("pause");
}