小胖七少爷
小胖七少爷

计算几何基础算法几何C++实现

 

算法目录

目前实现的算法包括点、向量、线段、直线、三角形、多边形、圆等基本计算几何模型。

一、点和向量

1、两点之间的距离

2、点到线的距离

3、点到线的投影点

4、点关于线的对称点

5、点是否在线上

6、三点是否共线

7、向量长度

8、向量标准化

9、向量点乘

10、向量叉乘

11、向量夹角

12、向量正弦、余弦、正切

13、随机生成n个点

二、直线和线段

1、线段/直线是否相交/平行

2、直线的夹角

3、一阶贝塞尔曲线插值

4、二阶贝塞尔曲线插值

5、三阶贝塞尔曲线插值

三、三角形

1、三个点是否能够组成三角形

2、点是否在三角形内部

3、点到平面的投影点

4、点到平面的距离

5、线段和平面的交点

6、计算平面的单位法向量

7、计算三角形面积

8、随机生成n条线

四、多边形

1、判断多边形顶点的凹凸性

2、判断多边形是否为凸多边形

3、计算多边形围成的面积

4、判断多边形是否是按照逆时针排列

5、判断点是否在多边形内部

6、判断线段是否在多边形内部

7、判断圆是否在多边形内部

8、寻找点集合的凸包算法

9、求简单多边形重心

10、求肯定在多边形内部的一个点

11、计算多边形的范围

五、圆

1、点和圆的关系

2、线段和圆的关系

3、直线和圆的关系

4、圆与圆的关系

// Copyright (C) Common Computational Geometry Algorithms e.U, ZutterHao
//
// This file is implementation of Common Common Computational Geometry Algorithms.
//
// Please please pay attention to input according to the specified data type.
//
// Author: ZutterHao .Nanjing University ,VISG
// Github: https://github.com/fanghao6666

// 个人实现的一些计算几何中常见的算法，包括点，线，多边形等
// 所有算法只依赖于C++标准库，不用包含任何其他第三方库
// 使用时请注意按照规定的数据类型进行输入
// 目前只使用C++来实现算法，具体算法原理会陆续在Github上更新
// Github: https://github.com/fanghao6666

/*** 包含的头文件 ***/
#include 
#include 
#include 
#include 
#include 

using namespace std;

/*** 常用常量 ***/
const double PI = 3.14159265;

/******************************* 基本几何数据类型 *******************************/
// 点,二维和三维,同时点也可以表示一个矢量
struct Point
{
    double x;    // x坐标
    double y;    // y坐标
    double z;    // z坐标（默认为0，如果需要三维点则给z赋值）

    Point(double a = 0, double b = 0, double c = 0) { x = a; y = b; z = c; } // 构造函数
};
// 点的加法
Point add(const Point& lhs, const Point& rhs)
{
    Point res;

    res.x = lhs.x + rhs.x;
    res.y = lhs.y + rhs.y;
    res.z = lhs.z + rhs.z;

    return res;
}
// 点的减法
Point sub(const Point& lhs, const Point& rhs)
{
    Point res;

    res.x = lhs.x - rhs.x;
    res.y = lhs.y - rhs.y;
    res.z = lhs.z - rhs.z;

    return res;
}
// 向量的乘法
Point mul(const Point& p, double ratio)
{
    Point res;

    res.x = p.x * ratio;
    res.y = p.y * ratio;
    res.z = p.z * ratio;

    return res;
}
// 向量的除法
Point div(const Point& p, double ratio)
{
    Point res;
    
    res.x = p.x / ratio;
    res.y = p.y / ratio;
    res.z = p.z / ratio;

    return res;
}
// 点判断相等
bool equal(const Point& lhs, const Point& rhs)
{
    return(lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z);
}
// 线,包括线段和直线
struct Line
{
    Point s;    // 起点
    Point e;    // 终点
    bool is_seg; // 是否是线段

    Line() {};    // 默认构造函数
    Line(Point a, Point b, bool _is_seg = true) { s = a; e = b; is_seg = _is_seg; }    // 构造函数(默认是线段)
};
// 三角形平面
struct Triangle
{
    Point v0;
    Point v1;
    Point v2;
    bool is_plane;

    Triangle() {}; // 默认构造函数
    Triangle(Point a, Point b, Point c, bool _is_plane = false) { v0 = a; v1 = b; v2 = c; is_plane = _is_plane; }// 构造函数（默认是三角形）
};

/******************************* 计算几何算法目录 *******************************/

// 一、点
// 1.1、两点之间的距离
double distance(const Point& p1, const Point& p2);

// 1.2、矢量长度
double length(const Point& vec);

// 1.3、矢量标准化
Point normalize(const Point& vec);

// 1.4、矢量点乘
double dotMultiply(const Point& op, const Point& p1, const Point& p2);
double dotMultiply(const Point& vec1, const Point& vec2);

// 1.5、矢量叉乘
Point multiply(const Point& op, const Point& p1, const Point& p2);
Point multiply(const Point& vec1, const Point& vec2);

// 1.6、点到线的距离
double ptolDistance(const Point& p, const Line& l);

// 1.7、点到线的投影点
Point ptolProjection(const Point& p, const Line& l);

// 1.8、点关于线的对称点
Point ptolSymmetry(const Point& p, const Line& l);

// 1.9、点是否在线上
bool isponl(const Point& p, const Line& l);

// 1.10、矢量夹角正弦
double Sin(const Point& op, const Point& p1, const Point& p2);
double Sin(const Point& vec1, const Point& vec2);

// 1.11、矢量夹角余弦
double Cos(const Point& op, const Point& p1, const Point& p2);
double Cos(const Point& vec1, const Point& vec2);

// 1.12、矢量夹角正切
double Tan(const Point& op, const Point& p1, const Point& p2);
double Tan(const Point& vec1, const Point& vec2);

// 1.13、矢量夹角角度
double Angle(const Point& op, const Point& p1, const Point& p2,bool is_radian = true);
double Angle(const Point& vec1, const Point& vec,bool is_radian = true);

// 1.14、判断三点是否共线
bool isPointsCollinear(const Point& p1, const Point& p2, const Point& p3);

// 二、线
// 2.1、线段是否相交
bool isSegIntersect(const Line& l1, const Line& l2,Point& inter_p);

// 2.2、求直线的夹角
double angleOfLines(const Line& l1, const Line& l2,bool is_radian = true);

// 2.3、一阶贝塞尔曲线插值
vector firstOrderBezier(const Point& s, const Point& e, int inter_num);

// 2.4、二阶贝塞尔曲线插值
vector secondOrderBezier(const Point& s, const Point& e, const Point& p,int inter_num);

// 2.5、三阶贝塞尔曲线插值
vector thirdOrderBezier(const Point& s, const Point& e, const Point& p1,const Point& p2,int inter_num);

// 三、三角形
// 3.1、三角形三个点是否能够构成三角形
bool isTriangle(const Triangle& t);

// 3.2、点是否在三角形内部
bool isPointInTriangle(const Triangle& t, const Point& p,double& u,double& v);

// 3.3、点到平面的投影点（距离最近的点）
Point ptotProjection(const Triangle& t, const Point& p);

// 3.4、点到平面的距离
double ptotDistance(const Triangle& t, const Point& p);

// 3.5、线段和平面的交点
Point ltotInterPoint(const Triangle& t, const Line& l);

// 3.6、计算平面的单位法向量
Point getUnitNormal(const Triangle& t);

// 3.7、计算三角形的面积
double areaOfTriangle(const Triangle& t);


// 四、多边形
// 4.1、判断多边形顶点的凹凸性
void checkConvex(const vector& polygon, vector& flags);

// 4.2、判断多边形是否为凸多边形
bool isConvex(const vector& polygon);

// 4.3、求多边形围成的面积
double areaOfPolygon(const vector& polygon);

// 4.4、判断多边形是否按照逆时针排列
bool isConterClock(const vector& polygon);

// 4.5、判断点是否在多边形内部
bool isPointInPolygon(const vector& polygon, const Point& p);

// 4.6、判断线段是否在多边形内部
bool isSegInPolygon(const vector& polygon, const Line& l);

// 4.7、判断圆是否在多边形内部
bool isCircleInPolygon(const vector& polygon, const Point& p, double radius);

// 4.8、寻找点集凸包算法（graham算法）
vector findConvexGraham(const vector& points);

// 4.9、寻找点集凸包算法（上下凸包法）时间复杂度O(nlogn)
vector findConvex(const vector& points);

// 4.10、求简单多边形重心
Point centerOfPolygon(const vector& polygon);

// 4.11、求肯定在多边形内部的一个点
Point pointInPolygon(const vector& polygon);

// 4.12、计算多边形的范围
void boxOfPolygon(const vector& polygon, Point& down_left, Point& up_right);

// 五、圆
// 5.1、点和圆的关系
int pointToCircle(const Point& c, double radius, const Point& p);

// 5.2、直线和圆的关系
int lineToCircle(const Point& c, double radius, const Line& l);

// 5.3、线段和圆的关系
int segToCircle(const Point& c, double radius, const Line& l);

// 5.4、两圆之间的关系
int circleToCircle(const Point& c1, double raduis1, const Point& c2, double radius2);



/******************************* 计算几何算法实现 *******************************/
//一、点

// 1.1、两点之间的距离
//
// 参数：p1 : 第一个点 p2: 第二个点
//  
double distance(const Point& p1, const Point& p2)
{
    return(sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2) + pow(p1.z - p2.z, 2)));
}

// 1.2、矢量的长度
//
// 参数： vec 矢量
//
double length(const Point& vec)
{
    return (sqrt(pow(vec.x, 2) + pow(vec.y, 2) + pow(vec.z, 2)));
}

// 1.3、矢量标准化（矢量的长度规约到1）
//
// 参数： vec ： 矢量
//
Point normalize(const Point& vec)
{
    Point res;

    res = div(vec, length(vec));

    return res;
}

// 1.4、矢量点乘
//
// 参数：(p1-op)为矢量1，（p2-op）为矢量2
//
double dotMultiply(const Point& op, const Point& p1, const Point& p2)
{
    return ((p1.x - op.x) * (p2.x - op.x) + (p1.y - op.y) * (p2.y - op.y) + (p1.z - op.z) * (p2.z - op.z));
}
// 参数：vec1为矢量1，vec2为矢量2
//
double dotMultiply(const Point& vec1, const Point& vec2)
{
    return(vec1.x * vec2.x + vec1.y * vec2.y + vec1.z * vec2.z);
}

// 1.5、矢量叉乘
//
// 参数：(p1-op)为矢量1，（p2-op）为矢量2
// 
Point multiply(const Point& op, const Point& p1, const Point& p2)
{
    Point result;

    result.x = (p1.y - op.y) * (p2.z - op.z) - (p2.y - op.y) * (p1.z - op.z);
    result.y = (p1.z - op.z) * (p2.x - op.x) - (p2.z - op.z) * (p1.x - op.x);
    result.z = (p1.x - op.x) * (p2.y - op.y) - (p2.x - op.x) * (p1.y - op.y);

    return result;
}
// 参数： vec1为矢量1，vec2为矢量2
//
Point multiply(const Point& vec1, const Point& vec2)
{
    Point result;

    result.x = vec1.y * vec2.z - vec2.y * vec1.z;
    result.y = vec1.z * vec2.x - vec2.z * vec1.x;
    result.z = vec1.x * vec2.y - vec2.x * vec1.y;

    return result;
}

// 1.6、点到线的距离
// 
// 参数： p : 点  l：直线
//
double ptolDistance(const Point& p, const Line& l)
{
    Point line_vec = sub(l.e,l.s);
    Point point_vec = sub(p, l.s);

    // 首先计算点在线段投影长度
    double project_len = dotMultiply(line_vec, point_vec) / length(line_vec);

    // 根据勾股定理计算点的距离
    double distance = sqrt(pow(length(line_vec), 2) - pow(project_len, 2));

    return distance;
}

// 1.7、点到线的投影点
//
// 参数：p : 点  l : 线
//
Point ptolProjection(const Point& p, const Line& l)
{
    Point line_vec = sub(l.e, l.s);
    Point point_vec = sub(p, l.s);
    Point unit_line_vec = normalize(line_vec);

    // 计算投影长度
    double project_len = dotMultiply(point_vec, unit_line_vec);

    // 投影点
    Point project_p = add(l.s,mul(unit_line_vec, project_len));

    return project_p;
}

// 1.8、点关于线的对称点
//
// 参数： p : 点  l : 对称线
//
Point ptolSymmetry(const Point& p, const Line& l)
{
    // 首先求出点在直线上的投影点
    Point project_p = ptolProjection(p, l);

    // 点到投影点的向量
    Point project_vec = sub(project_p, p);

    // 对称点
    Point symmetry_p = add(p, mul(project_vec, 2));

    return symmetry_p;
}

// 1.9、点是否在线上
// 线分为直线和线段，直线表示的是直线是否经过点
//
// 参数：p : 点  l : 线段或者线
// 
bool isponl(const Point& p, const Line& l)
{
    Point line_vec = sub(l.e, l.s);
    Point point_vec1 = sub(p, l.s);
    Point point_vec2 = sub(p, l.e);

    Point mul_vec = multiply(line_vec, point_vec1);
    double dot = dotMultiply(point_vec1, point_vec2);
    // 点是否在线段上
    if (l.is_seg)
    {
        if (equal(p,l.s) || equal(p,l.e))
            return true;
        return (0.0 == length(mul_vec) && dot < 0.0);
        
    }
    // 点是否在直线上
    else
    {
        return (0.0 == length(mul_vec));
    }
}

// 1.10、矢量夹角正弦
//
// 参数： op : 矢量公共点 p1 : 矢量1端点 p2 : 矢量2端点
//
double Sin(const Point& op, const Point& p1, const Point& p2)
{
    Point vec1 = sub(p1, op);
    Point vec2 = sub(p2, op);

    return Sin(vec1, vec2);
}
// 参数： vec1 矢量1  vec2 矢量2
// 
double Sin(const Point& vec1, const Point& vec2)
{
    return sqrt(1.0 - pow(Cos(vec1, vec2), 2));
}

// 1.11、矢量夹角余弦
//
// 参数： op : 矢量公共点 p1 : 矢量1端点 p2 : 矢量2端点
//
double Cos(const Point& op, const Point& p1, const Point& p2)
{
    Point vec1 = sub(p1, op);
    Point vec2 = sub(p2, op);

    return Cos(vec1, vec2);
}
// 参数： vec1 矢量1  vec2 矢量2
// 
double Cos(const Point& vec1, const Point& vec2)
{
    Point unit_vec1 = normalize(vec1);
    Point unit_vec2 = normalize(vec2);

    return dotMultiply(unit_vec1, unit_vec2);
}

// 1.12、矢量夹角正切
//
// 参数： op : 矢量公共点 p1 : 矢量1端点 p2 : 矢量2端点
//
double Tan(const Point& op, const Point& p1, const Point& p2)
{
    Point vec1 = sub(p1, op);
    Point vec2 = sub(p2, op);

    return Tan(vec1, vec2);
}
// 参数： vec1 矢量1  vec2 矢量2
// 
double Tan(const Point& vec1, const Point& vec2)
{
    double cos = Cos(vec1, vec2);
    double sin = Sin(vec1, vec2);

    // 分母不为零
    if (0.0 == cos)
        return -1;
    else
        return (sin / cos);
}

// 1.13、计算点的夹角角度
// 参数:  op : 矢量公共点 p1 : 矢量1端点 p2 : 矢量2端点 is_radian : 默认为弧度制
//
double Angle(const Point& op, const Point& p1, const Point& p2, bool is_radian)
{
    double cos_value = Cos(op, p1, p2);

    if (is_radian)
    {
        return acos(cos_value);
    }
    else
    {
        return (acos(cos_value) / PI * 180.0);
    }
}
// 参数： vec1 : 矢量1 vec2 : 矢量2
// 
double Angle(const Point& vec1, const Point& vec2,bool is_radian)
{
    double cos_value = Cos(vec1, vec2);

    if (is_radian)
    {
        return acos(cos_value);
    }
    else
    {
        return (acos(cos_value) / PI * 180.0);
    }
}

// 1.14、判断三点是否共线
bool isPointsCollinear(const Point& p1, const Point& p2, const Point& p3)
{
    Line line(p1, p2, false);

    // 判断第三个点是否在前两个点的线段上
    return isponl(p3, line);
}

// 二、线

// 2.1、线段是否相交
// 其中如果线段的端点重合或者某个线段端点在另一个线段上也算相交
// 线段判断是否相交，如果是直线则相当于判断是否平行
//
// 参数： l1 : 线段1  l2 : 线段2  inter_p : 如果相交返回交点
//
bool isSegIntersect(const Line& l1, const Line& l2,Point& inter_p)
{
    Point line1 = sub(l1.e, l1.s);
    Point line2 = sub(l2.e, l2.s);
    Point norm1 = normalize(line1);
    Point norm2 = normalize(line2);
    // 线段相交
    if (l1.is_seg)
    {
        // 端点在线段上
        if (isponl(l1.s, l2))
        {
            inter_p = l1.s;
            return true;
        }
        if (isponl(l1.e, l2))
        {
            inter_p = l1.e;
            return true;
        }
        if (isponl(l2.s, l1))
        {
            inter_p = l2.s;
            return true;
        }
        if (isponl(l2.e, l1))
        {
            inter_p = l2.e;
            return true;
        }
        // 判断线段是否相互跨立
        double dot1 = dotMultiply(multiply(sub(l2.s, l1.s), line1), multiply(sub(l2.e, l1.s), line1));
        double dot2 = dotMultiply(multiply(sub(l1.s, l2.s), line2), multiply(sub(l1.e, l2.s), line2));
        if (dot1 < 0.0 && dot2 < 0.0)
        {
            double t1 = length(multiply(sub(l1.s, l2.s), norm2)) / length(multiply(norm2, norm1));
            double t2 = length(multiply(sub(l2.s, l1.s), norm1)) / length(multiply(norm1, norm2));

            inter_p = add(l1.s, mul(norm1, t1));
            return true;
        }
        else
        {
            return false;
        }

    }
    // 直线相交
    else
    {
        if (Cos(line1, line2) == 1.0)
            return false;

        double t1 = length(multiply(sub(l1.s, l2.s), norm2)) / length(multiply(norm2, norm1));
        double t2 = length(multiply(sub(l2.s, l1.s), norm1)) / length(multiply(norm1, norm2));

        inter_p = add(l1.s, mul(norm1, t1));
        return true;
    }
}

// 2.2、求直线的夹角
// 
// 
// 参数： l1 : 线段1 l2 : 线段2
//
double angleOfLines(const Line& l1, const Line& l2,bool is_radian)
{
    Point line1 = sub(l1.e, l1.s);
    Point line2 = sub(l2.e, l2.s);

    return Angle(line1, line2, is_radian);
}

// 2.3、一阶贝塞尔曲线插值
// 
// 参数： s： 起点 e : 终点 inter_num：插值点数量（不包括起始点）
// 返回值包括起始点
//
vector firstOrderBezier(const Point& s, const Point& e, int inter_num)
{
    vector res;
    res.push_back(s);
    for (int i = 1; i <= inter_num; ++i)
    {
        double a1 = double(i) / double(inter_num + 1);
        double a2 = 1.0 - a1;
        res.push_back(add(mul(s, a2), mul(e, a1)));
    }
    res.push_back(e);

    return res;
}

// 2.4、二阶贝塞尔曲线插值
// 
// 参数： s： 起点 e : 终点 p : 控制点 inter_num：插值点数量（不包括起始点）
// 返回值包括起始点
//
vector secondOrderBezier(const Point& s, const Point& e, const Point& p, int inter_num)
{
    vector res;
    res.push_back(s);
    for (int i = 1; i <= inter_num; ++i)
    {
        double a = double(i) / double(inter_num + 1);
        double a1 = pow(a,2);
        double a2 = 2 * a * (1.0 - a);
        double a3 = pow(1.0 - a, 2);
        res.push_back(add(add(mul(s, a3), mul(p, a2)), mul(e, a1)));
    }
    res.push_back(e);

    return res;
}

// 2.5、三阶贝塞尔曲线插值
// 
// 参数： s： 起点 e : 终点 p1，p2 : 控制点 inter_num：插值点数量（不包括起始点）
// 返回值包括起始点
//
vector thirdOrderBezier(const Point& s, const Point& e, const Point& p1, const Point& p2, int inter_num)
{
    vector res;
    res.push_back(s);
    for (int i = 1; i <= inter_num; ++i)
    {
        double a = double(i) / double(inter_num + 1);
        double a1 = pow(a, 3);
        double a2 = 3 * pow(a, 2) * (1.0 - a);
        double a3 = 3 * pow(1.0 - a, 2) * a;
        double a4 = pow(1.0 - a, 3);
        res.push_back(add(add(add(mul(s, a4), mul(p1, a3)), mul(p2, a2)),mul(e,a1)));
    }
    res.push_back(e);

    return res;
}

// 三、三角形

// 3.1、三角形三个点是否能够构成三角形
// 不共线的三个点组成一个三角形
// 
// 参数： t : 三角形
// 
bool isTriangle(const Triangle& t)
{
    return isPointsCollinear(t.v0, t.v1, t.v2);
}

// 3.2、点是否在三角形内部（重心法）
// 算法方法链接： https://www.cnblogs.com/graphics/archive/2010/08/05/1793393.html
//
// 参数： t : 三角形 p : 需要判断的点 u,v分别为用于表示点在两条边上投影系数
//
bool isPointInTriangle(const Triangle& t, const Point& p, double& u, double& v)
{
    Point vec1 = sub(t.v1, t.v0);
    Point vec2 = sub(t.v2, t.v0);
    Point vec_p = sub(p, t.v0);

    double dot00 = dotMultiply(vec1, vec1);
    double dot01 = dotMultiply(vec1, vec2);
    double dot02 = dotMultiply(vec1, vec_p);
    double dot11 = dotMultiply(vec2, vec2);
    double dot12 = dotMultiply(vec2, vec_p);

    double inverDeno = 1 / (dot00 * dot11 - dot01 * dot01);

    u = (dot11 * dot02 - dot01 * dot12) * inverDeno;
    v = (dot00 * dot12 - dot01 * dot02) * inverDeno;

    if (u < 0 || u > 1) return false;
    if (v < 0 || v > 1) return false;
    if (u + v < 1)return true;
    else return false;
}

// 3.3、点到平面最近的点，即点到平面的投影
// 
// 参数：t : 三角形 p : 点
// 
Point ptotProjection(const Triangle& t, const Point& p)
{
    Point vec_p = sub(p, t.v0);
    Point unit_normal = getUnitNormal(t);

    double ratio = dotMultiply(vec_p, unit_normal);

    return sub(p, mul(unit_normal, ratio));
}

// 3.4、点到平面的距离
//
// 参数： t : 三角形所在的平面 p : 需要判断的点
//
double ptotDistance(const Triangle& t, const Point& p)
{
    Point project_p = ptotProjection(t, p);

    return distance(p, project_p);
}

// 3.5、线段和平面的交点
// 
// 参数： t : 三角形所在平面 l : 直线
//
Point ltotInterPoint(const Triangle& t, const Line& l)
{
    Point line_vec = sub(l.e, l.s);
    Point point_vec = sub(t.v0, l.s);
    Point unit_plane_normal = getUnitNormal(t);

    double ratio = dotMultiply(point_vec, unit_plane_normal) / dotMultiply(unit_plane_normal, line_vec);

    return add(l.s, mul(line_vec, ratio));
}

// 3.6、计算平面的单位法向量
// 
// 参数： t : 三角形平面
// 
Point getUnitNormal(const Triangle& t)
{
    Point vec1 = sub(t.v1, t.v0);
    Point vec2 = sub(t.v2, t.v0);

    return normalize(multiply(vec1, vec2));
}

// 3.7、计算三角形的面积
//
// 参数： t : 三角形平面
//
double areaOfTriangle(const Triangle& t)
{
    return (0.5 * length(multiply(sub(t.v1,t.v0),sub(t.v2,t.v0))));
}

// 四、多边形
// 如果没有特别说明，则默认输入多边形顶点按照逆时针排列，点为二维点即z=0

// 4.1、判断多边形顶点的凹凸性
// 
// 参数： polygon : 多边形点集合 flags : 标志每个点是否是凸的
//
void checkConvex(const vector& polygon, vector& flags)
{
    flags.resize(polygon.size());

    // 找到第一个凸的顶点
    int index = 0;
    for (int i = 1; i < polygon.size(); ++i)
    {
        if (polygon[i].y < polygon[index].y ||
            (polygon[i].y == polygon[index].y && polygon[i].x < polygon[index].x))
        {
            index = i;
        }
    }
    /* 判断每个点的凹凸性 
    *  通过判断前后两个点的向量叉乘判断是否满足逆时针
    */
    int size = polygon.size() - 1;
    flags[index] = true;
    while (size)
    {
        if (multiply(polygon[index], polygon[(index + 1) % size], polygon[(index + 2) % size]).z >= 0)
        {
            flags[(index + 1) % size] = true;
        }
        else
        {
            flags[(index + 1) % size] = false;
        }
        index++;
        size--;
    }
}

// 4.2、判断多边形是否为凸多边形
//
// 参数 ： polygon : 输入的多边形顶点
//
bool isConvex(const vector& polygon)
{
    vector flags;
    // 判断每个点的凹凸性
    checkConvex(polygon, flags);
    // 如果有一个点不是凸的，则此多边形为非凸
    for (auto c : flags)
        if (!c)
            return false;
    return true;
}

// 4.3、求多边形围成的面积
//
// 参数： polygon : 多边形
//
double areaOfPolygon(const vector& polygon)
{
    // 如果多边形点的数量少于三个则非法
    int size = polygon.size();
    if (size < 3) return 0;

    double area(0.0);
    for (int i = 0; i < size; ++i)
    {
        area += polygon[i].y * (polygon[(i - 1 + size) % size].x - polygon[(i + 1) % size].x);
    }

    return (area / 2);
}

// 4.4、判断多边形是否按照逆时针排列
//
// 参数： polygon : 多边形
//
bool isConterClock(const vector& polygon)
{
    return areaOfPolygon(polygon) > 0;
}

// 4.5、判断点是否在多边形内部
// 判断从点引出一条线段与多边形的交点的个数
// 奇数个则相交、偶数个则不相交
// 
// 参数： polygon : 多边形 p : 需要判断的点
//
bool isPointInPolygon(const vector& polygon, const Point& p)
{
    Point down_left, up_right;
    boxOfPolygon(polygon, down_left, up_right);
    
    // 位于多边形外部一点
    Point out_p = sub(down_left, Point(10.0, 0.0));
    
    int cnt(0);
    Line p_line(p, out_p, true);
    for (int i = 0; i < polygon.size(); ++i)
    {
        Point s = polygon[i];
        Point e = polygon[(i + 1) % polygon.size()];
        Line seg(s, e, true);
        Point inter_p;
        if (isSegIntersect(p_line, seg, inter_p))
        {
            cnt++;
        }
    }

    return (cnt % 2 == 1);
}

// 4.6、判断线段是否在多边形内部
// 线段在多边形内部的条件是两个端点都在多边形内且不与多边形相交
// 
// 参数： polygon : 多边形 l ： 线段
bool isSegInPolygon(const vector& polygon, const Line& l)
{
    // 首先判断线段端点是否都在多边形内部
    bool is_s_in = isPointInPolygon(polygon, l.s);
    bool is_e_in = isPointInPolygon(polygon, l.e);

    // 然后判断线段是否相交
    if (is_s_in && is_e_in)
    {
        for (int i = 0; i < polygon.size(); ++i)
        {
            Point s = polygon[i];
            Point e = polygon[(i + 1) % polygon.size()];
            Line seg(s, e, true);
            Point inter_p;
            if (isSegIntersect(l, seg, inter_p))
            {
                return false;
            }
        }
        return true;
    }
    else
    {
        return false;
    }
}

// 4.7、判断圆是否在多边形内部
// 只有多边形所有的边都在圆的外部，圆才处于多边形内部
//
//    参数： polygon : 多边形 c : 圆心 radius ： 半径
//
bool isCircleInPolygon(const vector& polygon, const Point& c, double radius)
{
    for (int i = 0; i < polygon.size(); ++i)
    {
        const Point& p1 = polygon[i];
        const Point& p2 = polygon[(i + 1) % polygon.size()];
        Line line(p1, p2, true);
        if (segToCircle(c, radius, line) != 2)
            return false;
    }
    return true;
}

// 4.8、寻找点集凸包算法（graham算法）
// 算法链接：https://blog.csdn.net/acm_zl/article/details/9342631
//
// 参数： points ： 平面点集
//
vector findConvexGraham(const vector& points)
{
    vector result;

    // 点的数量必须大于三个
    if (points.size() < 3)
        return result;

    // 寻找最底部的点
    int index = 0;
    for (int i = 0; i < points.size(); ++i)
    {
        if (points[i].y < points[index].y)
        {
            index = i;
        }
    }
    Point convex_p = points[index];

    // 计算每个点的极角
    map cos_map;
    Point x_vec(1.0, 0.0);
    for (int i = 0; i < points.size(); ++i)
    {
        if (i != index)
        {
            double cos_value = Cos(sub(points[i], convex_p), x_vec);
            // 如果有多个点有相同的极角，则取最远的点
            if (cos_map.count(-cos_value) != 0)
            {
                if (length(points[i]) > length(points[cos_map[-cos_value]]))
                    cos_map[-cos_value] = i;
            }
            else
                cos_map[-cos_value] = i;
        }
    }
    
    // 保存结果的栈
    stack result_stack;
    // 存入开始的两个点
    result_stack.push(index);
    result_stack.push(cos_map.begin()->second);

    for (auto iter = (++cos_map.begin()); iter != cos_map.end(); ++iter)
    {
        int first = result_stack.top();
        result_stack.pop();
        int second = result_stack.top();

        Point vec1 = sub(points[first], points[second]);
        Point vec2 = sub(points[iter->second], points[first]);
        if (multiply(vec1, vec2).z >= 0)
            result_stack.push(first);
        result_stack.push(iter->second);
    }

    // 将数据从栈中读取
    while (!result_stack.empty())
    {
        result.push_back(points[result_stack.top()]);
        result_stack.pop();
    }

    std::reverse(result.begin(), result.end());

    return result;
}

// 4.9、寻找点集凸包算法（上下凸包法）时间复杂度O(nlogn)
//
//    参数： points : 平面点集
//
// 点根据字典序的比较函数
bool cmp(Point a, Point b)
{
    if (a.x == b.x)
        return a.y < b.y;
    return a.x < b.x;
}
vector findConvex(const vector& points)
{
    vector result;
    if (points.size() < 3)
        return result;

    vector tmp_points = points;
    // 首先将所有点按照字典序排序
    sort(tmp_points.begin(), tmp_points.end(), cmp);

    // 上凸包
    vector upper_hull;
    // 存入第一个和第二个点
    upper_hull.push_back(tmp_points[0]);
    upper_hull.push_back(tmp_points[1]);
    for (int i = 2; i < tmp_points.size(); ++i)
    {
        upper_hull.push_back(tmp_points[i]);
        while (upper_hull.size() > 2 && multiply(sub(upper_hull[upper_hull.size() - 2], upper_hull[upper_hull.size() - 3]), sub(upper_hull[upper_hull.size() - 1], upper_hull[upper_hull.size() - 3])).z >= 0)
        {
            upper_hull.erase(upper_hull.end() - 2);
        }
    }
    // 下凸包
    vector lower_hull;
    // 存入倒数第一第二个点
    lower_hull.push_back(tmp_points[tmp_points.size() - 1]);
    lower_hull.push_back(tmp_points[tmp_points.size() - 2]);
    for (int i = tmp_points.size() - 3; i >= 0; --i)
    {
        lower_hull.push_back(tmp_points[i]);
        while (lower_hull.size() > 2 && multiply(sub(lower_hull[lower_hull.size() - 2], lower_hull[lower_hull.size() - 3]), sub(lower_hull[lower_hull.size() - 1], lower_hull[lower_hull.size() - 3])).z >= 0)
        {
            lower_hull.erase(lower_hull.end() - 1);
        }
    }
    // 删除重复点
    lower_hull.erase(lower_hull.begin());
    lower_hull.erase(lower_hull.end() - 1);

    // 合并上下凸包
    upper_hull.insert(upper_hull.end(), lower_hull.begin(), lower_hull.end());

    result = upper_hull;

    return result;
}

// 4.10、求简单多边形重心
// 算法原理链接：
//
// 参数： polygon ： 简单多边形
//
Point centerOfPolygon(const vector& polygon)
{
    double polygon_area(0.0);
    Point center;
    Point origin;

    for (int i = 0; i < polygon.size(); ++i)
    {
        Point curr_p = polygon[i];
        Point next_p = polygon[(i + 1) % polygon.size()];
        Triangle t(origin, curr_p, next_p);

        double curr_area = areaOfTriangle(t);
        polygon_area += curr_area;

        center = add(center, mul(div(add(curr_p, next_p), 3), curr_area));
    }

    center = div(center, polygon_area);

    return center;
}

// 4.11、求肯定在多边形内部的一个点
// 定理1: 每个多边形至少有一个凸顶点，
//          x坐标最大、最小的点肯定是凸顶点，y坐标最大、最小的点肯定是凸顶点
// 定理2：顶点数>= 4的简单多边形至少有一条对角线
//
// 参数： polygon ： 简单多边形
//
Point pointInPolygon(const vector& polygon)
{
    // 凸顶点和索引
    int index = 0;
    Point convex_p = polygon[0];
    // 寻找一个凸顶点
    for (int i = 0; i < polygon.size(); ++i)
    {
        if (polygon[i].y < convex_p.y)
        {
            index = i;
            convex_p = polygon[i];
        }
    }
    // 获取凸顶点前后一个点
    int size = polygon.size();
    Point pre_p = polygon[(index - 1 + size) % size];
    Point next_p = polygon[(index + 1) % size];
    Triangle t(convex_p, pre_p, next_p);
    double min_d = double(INT_MAX);
    bool flag = false;
    Point min_p;
    for (int i = 0; i < polygon.size(); ++i)
    {
        if (i == index || i == ((index - 1 + size) % size) || i == ((index + 1) % size))
            continue;
        flag = true;
        if (distance(convex_p, polygon[i]) < min_d)
        {
            min_p = polygon[i];
            min_d = distance(convex_p, polygon[i]);
        }
    }
    // 如何没有顶点在三角形内部，则返回前后点的中点
    if (!flag)
    {
        return div(add(pre_p, next_p), 2);
    }
    // 返回最近点和凸顶点的中点
    return div(add(convex_p, min_p), 2);
}

// 4.12、获取多边形的包围轮廓
// 即多边形的最小包围盒，由左下和右上两个点表示
//
// 参数： polygon : 多边形 down_left : 左下点  up_right : 右上点
//
void boxOfPolygon(const vector& polygon, Point& down_left, Point& up_right)
{
    double max_x = double(INT_MIN), min_x = double(INT_MAX);
    double max_y = double(INT_MIN), min_y = double(INT_MAX);

    for (auto c : polygon)
    {
        max_x = (c.x > max_x) ? c.x : max_x;
        min_x = (c.x < min_x) ? c.x : min_x;
        max_y = (c.y > max_y) ? c.y : max_y;
        min_y = (c.y < min_y) ? c.y : min_y;
    }

    down_left = Point(min_x, min_y);
    up_right = Point(max_x, max_y);
}


// 五、圆
// 5.1、点和圆的关系
//
// 参数： c: 圆心 radiuns ： 圆的半径  p : 判断的点
// 返回值 ： 0 ： 圆内 1 ： 圆上 2： 圆外
//
int pointToCircle(const Point& c, double radius, const Point& p)
{
    double ptoc_d = distance(c, p);

    if (ptoc_d < radius)
        return 0;
    else if (ptoc_d == radius)
        return 1;
    else
        return 2;
}

// 5.2、直线和圆的关系
//
// 参数： c: 圆心 radiuns ： 圆的半径  l : 判断的直线
// 返回值 ： 0 ： 相交 1 ：相切  2： 相离
//
int lineToCircle(const Point& c, double radius, const Line& l)
{
    double ctol_d = ptolDistance(c, l);

    if (ctol_d < radius)
        return 0;
    else if (ctol_d == radius)
        return 1;
    else
        return 2;
}

// 5.3、线段和圆的关系
//
// 参数： c: 圆心 radiuns ： 圆的半径  l : 判断的线段
// 返回值 ： 0 ： 圆内 1 ： 与圆相交  2： 圆外
//
int segToCircle(const Point& c, double radius, const Line& l)
{
    double ctol_d = ptolDistance(c, l);

    if (ctol_d > radius)
        return 2;
    else if (ctol_d == radius)
        return 1;
    else
    {
        Point project_p = ptolProjection(c, l);
        if (isponl(project_p, l))
            return 1;
        else
            return 2;
    }
}

// 5.4、两圆之间的关系
// 
// 参数： c1 : 圆1圆心，r1 圆1半径 c2 : 圆2圆心，r2 圆2半径
// 返回值：0 ：内含 1：内切 2：相交 3：外切 4：外离
//
int circleToCircle(const Point& c1, double r1, const Point& c2, double r2)
{
    double ctoc_d = distance(c1, c2);

    if (ctoc_d < abs(r1 - r2))
        return 0;
    else if (ctoc_d == abs(r1 - r2))
        return 1;
    else if (ctoc_d > abs(r1 - r2) && ctoc_d < (r1 + r2))
        return 2;
    else if (ctoc_d == (r1 + r2))
        return 3;
    else if (ctoc_d > (r1 + r2))
        return 4;
}

 

你可能感兴趣的:(C/C++,算法)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • 每日一题——第八十一题 互联网打工人no1 C语言程序设计每日一练c语言
    打印如下图案:#includeintmain(){inti,j;charch='A';for(i=1;i<5;i++,ch++){for(j=0;j<5-i;j++){printf("");//控制空格输出}for(j=1;j<2*i;j++)//条件j<2*i{printf("%c",ch);//控制字符输出}printf("\n");}return0;}
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • Algorithm 香水浓 javaAlgorithm
    冒泡排序 public static void sort(Integer[] param) { for (int i = param.length - 1; i > 0; i--) { for (int j = 0; j < i; j++) { int current = param[j]; int next = param[j + 1];
  • mongoDB 复杂查询表达式 开窍的石头 mongodb
    1:count    Pg: db.user.find().count();    统计多少条数据 2:不等于$ne    Pg: db.user.find({_id:{$ne:3}},{name:1,sex:1,_id:0});    查询id不等于3的数据。 3：大于$gt $gte(大于等于) &n
  • Jboss Java heap space异常解决方法, jboss OutOfMemoryError : PermGen space 0624chenhong jvmjboss
    转自 http://blog.csdn.net/zou274/article/details/5552630 解决办法： window->preferences->java->installed jres->edit jre 把default vm arguments 的参数设为-Xms64m -Xmx512m ----------------
  • 文件上传 下载 解析 相对路径 不懂事的小屁孩 文件上传
    有点坑吧，弄这么一个简单的东西弄了一天多，身边还有大神指导着，网上各种百度着。 下面总结一下遇到的问题： 文件上传，在页面上传的时候，不要想着去操作绝对路径，浏览器会对客户端的信息进行保护，避免用户信息收到攻击。 在上传图片，或者文件时，使用form表单来操作。 前台通过form表单传输一个流到后台，而不是ajax传递参数到后台，代码如下: <form action=&
  • 怎么实现qq空间批量点赞 换个号韩国红果果 qq
    纯粹为了好玩！！ 逻辑很简单 1 打开浏览器console；输入以下代码。 先上添加赞的代码 var tools={}; //添加所有赞 function init(){ document.body.scrollTop=10000; setTimeout(function(){document.body.scrollTop=0;},2000);//加
  • 判断是否为中文 灵静志远 中文
    方法一： public class Zhidao { public static void main(String args[]) { String s = "sdf灭礌 kjl d{';\fdsjlk是"; int n=0; for(int i=0; i<s.length(); i++) { n = (int)s.charAt(i); if((
  • 一个电话面试后总结 a-john 面试
    今天，接了一个电话面试，对于还是初学者的我来说，紧张了半天。 面试的问题分了层次，对于一类问题，由简到难。自己觉得回答不好的地方作了一下总结：   在谈到集合类的时候，举几个常用的集合类，想都没想，直接说了list,map。   然后对list和map分别举几个类型：   list方面：ArrayList,LinkedList。在谈到他们的区别时，愣住了
  • MSSQL中Escape转义的使用 aijuans MSSQL
    IF OBJECT_ID('tempdb..#ABC') is not null drop table tempdb..#ABC create table #ABC ( PATHNAME NVARCHAR(50) ) insert into #ABC SELECT N'/ABCDEFGHI' UNION ALL SELECT N'/ABCDGAFGASASSDFA' UNION ALL
  • 一个简单的存储过程 asialee mysql存储过程构造数据批量插入
               今天要批量的生成一批测试数据，其中中间有部分数据是变化的，本来想写个程序来生成的，后来想到存储过程就可以搞定，所以随手写了一个，记录在此：            DELIMITER $$ DROP PROCEDURE IF EXISTS inse
  • annot convert from HomeFragment_1 to Fragment 百合不是茶 android导包错误
    创建了几个类继承Fragment, 需要将创建的类存储在ArrayList<Fragment>中; 出现不能将new 出来的对象放到队列中,原因很简单;     创建类时引入包是:import android.app.Fragment;      创建队列和对象时使用的包是:import android.support.v4.ap
  • Weblogic10两种修改端口的方法 bijian1013 weblogic端口号配置管理config.xml
    一.进入控制台进行修改    1.进入控制台:  http://127.0.0.1:7001/console     2.展开左边树菜单         域结构->环境->服务器-->点击AdminServer(管理) &
  • mysql 操作指令 征客丶 mysql
    一、连接mysql 进入 mysql 的安装目录； $ bin/mysql -p [host IP 如果是登录本地的mysql 可以不写 -p 直接 -u] -u [userName] -p 输入密码，回车，接连； 二、权限操作［如果你很了解mysql数据库后，你可以直接去修改系统表，然后用 mysql> flush privileges; 指令让权限生效］ 1、赋权 mys
  • 【Hive一】Hive入门 bit1129 hive
    Hive安装与配置 Hive的运行需要依赖于Hadoop，因此需要首先安装Hadoop2.5.2，并且Hive的启动前需要首先启动Hadoop。   Hive安装和配置的步骤   1. 从如下地址下载Hive0.14.0   http://mirror.bit.edu.cn/apache/hive/    2.解压hive，在系统变
  • ajax 三种提交请求的方法 BlueSkator Ajaxjqery
    1、ajax 提交请求 $.ajax({ type:"post", url : "${ctx}/front/Hotel/getAllHotelByAjax.do", dataType : "json", success : function(result) { try { for(v
  • mongodb开发环境下的搭建入门 braveCS 运维
      linux下安装mongodb 1）官网下载mongodb-linux-x86_64-rhel62-3.0.4.gz 2）linux 解压  gzip -d mongodb-linux-x86_64-rhel62-3.0.4.gz; mv mongodb-linux-x86_64-rhel62-3.0.4 mongodb-linux-x86_64-rhel62-
  • 编程之美-最短摘要的生成 bylijinnan java数据结构算法编程之美
    import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; public class ShortestAbstract { /** * 编程之美 最短摘要的生成 * 扫描过程始终保持一个[pBegin,pEnd]的range,初始化确保[pBegin,pEnd]的ran
  • json数据解析及typeof chengxuyuancsdn jstypeofjson解析
    // json格式 var people='{"authors": [{"firstName": "AAA","lastName": "BBB"},' +' {"firstName": "CCC&
  • 流程系统设计的层次和目标 comsci 设计模式数据结构sql框架脚本
                                  流程系统设计的层次和目标  
  • RMAN List和report 命令 daizj oraclelistreportrman
    LIST 命令 使用RMAN LIST 命令显示有关资料档案库中记录的备份集、代理副本和映像副本的 信息。使用此命令可列出： • RMAN 资料档案库中状态不是AVAILABLE 的备份和副本 • 可用的且可以用于还原操作的数据文件备份和副本 • 备份集和副本，其中包含指定数据文件列表或指定表空间的备份 • 包含指定名称或范围的所有归档日志备份的备份集和副本 • 由标记、完成时间、可
  • 二叉树:红黑树 dieslrae 二叉树
        红黑树是一种自平衡的二叉树,它的查找,插入,删除操作时间复杂度皆为O(logN),不会出现普通二叉搜索树在最差情况时时间复杂度会变为O(N)的问题.     红黑树必须遵循红黑规则,规则如下     1、每个节点不是红就是黑。     2、根总是黑的  &
  • C语言homework3，7个小题目的代码 dcj3sjt126com c
    1、打印100以内的所有奇数。 # include <stdio.h> int main(void) { int i; for (i=1; i<=100; i++) { if (i%2 != 0) printf("%d ", i); } return 0; }  2、从键盘上输入10个整数，
  • 自定义按钮, 图片在上, 文字在下, 居中显示 dcj3sjt126com 自定义
    #import <UIKit/UIKit.h> @interface MyButton : UIButton -(void)setFrame:(CGRect)frame ImageName:(NSString*)imageName Target:(id)target Action:(SEL)action Title:(NSString*)title Font:(CGFloa
  • MySQL查询语句练习题，测试足够用了 flyvszhb sqlmysql
    http://blog.sina.com.cn/s/blog_767d65530101861c.html 1.创建student和score表 CREATE  TABLE  student ( id  INT(10)  NOT NULL  UNIQUE  PRIMARY KEY  , name  VARCHAR
  • 转：MyBatis Generator 详解 happyqing mybatis
      MyBatis Generator 详解 http://blog.csdn.net/isea533/article/details/42102297   MyBatis Generator详解 http://git.oschina.net/free/Mybatis_Utils/blob/master/MybatisGeneator/MybatisGeneator.
  • 让程序员少走弯路的14个忠告 jingjing0907 工作计划学习
      无论是谁，在刚进入某个领域之时，有再大的雄心壮志也敌不过眼前的迷茫：不知道应该怎么做，不知道应该做什么。下面是一名软件开发人员所学到的经验，希望能对大家有所帮助   1.不要害怕在工作中学习。 只要有电脑，就可以通过电子阅读器阅读报纸和大多数书籍。如果你只是做好自己的本职工作以及分配的任务，那是学不到很多东西的。如果你盲目地要求更多的工作，也是不可能提升自己的。放
  • nginx和NetScaler区别 流浪鱼 nginx
    NetScaler是一个完整的包含操作系统和应用交付功能的产品，Nginx并不包含操作系统，在处理连接方面，需要依赖于操作系统，所以在并发连接数方面和防DoS攻击方面，Nginx不具备优势。 2.易用性方面差别也比较大。Nginx对管理员的水平要求比较高，参数比较多，不确定性给运营带来隐患。在NetScaler常见的配置如健康检查，HA等，在Nginx上的配置的实现相对复杂。 3.策略灵活度方
  • 第11章 动画效果（下） onestopweb 动画
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • FAQ - SAP BW BO roadmap blueoxygen BOBW
    http://www.sdn.sap.com/irj/boc/business-objects-for-sap-faq   Besides, I care that how to integrate tightly.   By the way, for BW consultants, please just focus on Query Designer which i
  • 关于java堆内存溢出的几种情况 tomcat_oracle javajvmjdkthread
    【情况一】： 　　 java.lang.OutOfMemoryError: Java heap space：这种是java堆内存不够，一个原因是真不够，另一个原因是程序中有死循环； 　　如果是java堆内存不够的话，可以通过调整JVM下面的配置来解决： 　　<jvm-arg>-Xms3062m</jvm-arg> 　　<jvm-arg>-Xmx
  • Manifest.permission_group权限组 阿尔萨斯 Permission
    结构 继承关系 public static final class Manifest.permission_group extends Object java.lang.Object android. Manifest.permission_group 常量 ACCOUNTS 直接通过统计管理器访问管理的统计 COST_MONEY可以用来让用户花钱但不需要通过与他们直接牵涉的权限 D
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他