四叉树

#include <cmath> 
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

const int NUME_PLANETS = 10;//星球数量
const int TIME_COUNT = 20;
const int BORDER_LIMIT = 3200;//所有坐标绝对值都不超过3200

const double G = 1e-3;//万有引力常量
const double pi = acos(-1.0);//圆周率

double sqr(double x) {//平方
    return x * x;
};

//二维向量
class Vector {
public:
    double x, y;

    Vector():x(0), y(0){}
    Vector(double x, double y):x(x), y(y){}
    ~Vector() {}

    void operator = (const Vector &v) {
        x = v.x;
        y = v.y;
    }

    Vector operator + (const Vector &v) {
        return Vector(x + v.x, y + v.y);
    }

    Vector operator - (const Vector &v) {
        return Vector(x - v.x, y - v.y);
    }

    Vector operator * (double f) {
        return Vector(x * f, y * f);
    }

    Vector operator / (double f) {
        //return (*this) * (1.0 / f);
        return Vector(x / f, y / f);
    }

    double length() {//返回长度的平方
        return sqr(x) + sqr(y);
    }

    void factor() {//将该向量变为单位向量
        double len = sqrt(length());
        x /= len;
        y /= len;
    }

    void print() {
        cout << "(" << x << "," << y << ")";
    }
};

//星球结构体
class Planet {
public:
    Vector pos;//位置
    Vector v;//速度
    Vector a;//加速度
    double m;//质量
};

//封装四叉树 
namespace QuatTree {
    const int SON = 4;//儿子个数，使用常量易于拓展，比如想拓展为八叉树只需要修改此常量为8即可
    const int SIZE = 1e5 + 5;//预开SIZE个Node节点备用，应保证 SIZE >= NUME_PLANETS * log2(N), N表示初始边界大小

    //四叉树的节点
    struct Node {
        double mass;//质量
        Vector center;//重心
        bool isleaf;//是否为叶子节点
        Node* child[SON];
        /*当前节点的四个儿子节点,分布如下
         * 01
         * 23
         */
        
        Node():mass(0), isleaf(0), center(){
            for (int i = 0; i < SON; i ++)
                child[i] = NULL;
        }
        ~Node() {}

        void init(Planet *p);//使用一个星球对四叉树节点进行初始化
        void update();//使用四个儿子节点的信息更新当前节点的信息
    };

    Node *null = new Node();//空指针，使用自定义null而不用NULL可以减少 if(Node == NULL) 的判断
    Node *root;//四叉树的根

    void Node::init(Planet *p) {
        mass = p -> m;
        isleaf = 1;
        center = p -> pos;
        child[0] = null;
        child[1] = null;
        child[2] = null;
        child[3] = null;
    }

    void Node::update() {
        mass = 0;
        isleaf = 1;
        center.x = center.y = 0;
        for (int i = 0; i < SON; i ++) {
            if (child[i] == null) continue;
            isleaf = 0;
            mass += child[i] -> mass; 
            center.x += child[i] -> mass * (child[i] -> center).x;
            center.y += child[i] -> mass * (child[i] -> center).y;
        }
        center.x /= mass;
        center.y /= mass;
    }

    Node pool[SIZE];//内存池
    int count;//内存池的计数器

    void init() {//四叉树初始化
        count = 0;
        root = null;
    }

    Node *getNewNode() {//从内存池中获得一个Node指针
        return &(pool[count ++]);
    }    

    void insert(Node *&o, Planet *p, 
        double lx = -BORDER_LIMIT, double rx = BORDER_LIMIT, 
        double ly = -BORDER_LIMIT, double ry = BORDER_LIMIT) {
        //当前处理的二位平面为 lx <= x < rx, ly <= y < ry
        if (o == null) {
            o = getNewNode();
            o -> init(p);
            return;
        }
        double midx = (lx + rx) / 2, midy = (ly + ry) / 2;
        if ((p -> pos).x < midx) {
            if ((p -> pos).y < midy) insert(o -> child[0], p, lx, midx, ly, midy);
            else insert(o -> child[2], p, lx, midx, midy, ry);
        }    
        else {
            if ((p -> pos).y < midy) insert(o -> child[1], p, lx, midx, ly, midy);
            else insert(o -> child[3], p, lx, midx, midy, ry);
        }
        o -> update();
    }

    Planet calc(Planet *p, Node *o, int tim = 1000) {
        //计算星球p，在已建好的四叉树o中，经过时间tim之后的状态

    }

    vector<Planet> getQuatTree(vector<Planet> planets, int tim = 1000) {
        //星球集合planets经过时间tim后的状态，tim单位为ms，默认为1000ms
        init();//初始化
        int n = planets.size();//获得星球数量

        for (int i = 0; i < n; i ++) {
            insert(root, &planets[i]);
        }

        vector<Planet> result(n);
        for (int i = 0; i < n; i ++) {
            result[i] = calc(&planets[i], root, tim);
        }

        return result;
    }
} 

int main() {
    vector<Planet> planets(NUME_PLANETS);
    int num = NUME_PLANETS;

    /*生成所有星球初始值
     */ 

    /*每隔一定时间进行一次计算即可，使用方法如下
     * for (int i = 0; i < times; i ++) {//计算times次
     *     planets = QuatTree::getQuatTree(planets);
     *        print(planets);//输出所有星球信息
     * }
     */
    return 0;
}