将ply文件的最小生成树的各个节点根据1个邻近点2个邻近点3个邻近点分为三类的c++代码

以下是用C++实现的将ply文件的最小生成树的节点根据邻近点数量分为三类的代码：

#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <cmath>

using namespace std;

// 定义节点结构体
struct Node {
    int id; // 节点id
    double x; // 节点x坐标
    double y; // 节点y坐标
    double z; // 节点z坐标
    vector<int> adj; // 邻近节点id
    bool visited; // 是否已访问
};

// 定义边结构体
struct Edge {
    int from; // 起始节点id
    int to; // 终止节点id
    double weight; // 权重（距离）
};

// 定义比较函数，用于优先队列排序
struct cmp {
    bool operator() (Edge a, Edge b) {
        return a.weight > b.weight;
    }
};

// 计算两个节点之间的距离
double distance(Node a, Node b) {
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    double dz = a.z - b.z;
    return sqrt(dx*dx + dy*dy + dz*dz);
}

// 读取ply文件，返回所有节点
vector<Node> read_ply_file(string filename) {
    vector<Node> nodes;
    int num_vertices = 0;
    int num_edges = 0;
    ifstream infile(filename);
    if (infile.is_open()) {
        string line;
        while (getline(infile, line)) {
            if (line.find("element vertex") != string::npos) {
                sscanf(line.c_str(), "element vertex %d", &num_vertices);
            }
            if (line.find("element edge") != string::npos) {
                sscanf(line.c_str(), "element edge %d", &num_edges);
            }
            if (line.find("end_header") != string::npos) {
                break;
            }
        }
        for (int i = 0; i < num_vertices; i++) {
            Node node;
            infile >> node.x >> node.y >> node.z;
            node.id = i;
            node.visited = false;
            nodes.push_back(node);
        }
        for (int i = 0; i < num_edges; i++) {
            int from, to;
            infile >> from >> to;
            nodes[from].adj.push_back(to);
            nodes[to].adj.push_back(from);
        }
        infile.close();
    }
    return nodes;
}

// 计算最小生成树，返回所有边
vector<Edge> minimum_spanning_tree(vector<Node> &nodes) {
    vector<Edge> mst;
    priority_queue<Edge, vector<Edge>, cmp> pq;
    nodes[0].visited = true;
    for (int i = 0; i < nodes[0].adj.size(); i++) {
        int id = nodes[0].adj[i];
        pq.push({0, id, distance(nodes[0], nodes[id])});
    }
    while (!pq.empty()) {
        Edge e = pq.top();
        pq.pop();
        if (nodes[e.to].visited) {
            continue;
        }
        mst.push_back(e);
        nodes[e.to].visited = true;
        for (int i = 0; i < nodes[e.to].adj.size(); i++) {
            int id = nodes[e.to].adj[i];
            if (!nodes[id].visited) {
                pq.push({e.to, id, distance(nodes[e.to], nodes[id])});
            }
        }
    }
    return mst;
}

// 将节点根据邻近点数量分为三类
void classify_nodes(vector<Node> &nodes) {
    for (int i = 0; i < nodes.size(); i++) {
        if (nodes[i].adj.size() == 1) {
            cout << "Node " << i << " has 1 adjacent node." << endl;
        }
        else if (nodes[i].adj.size() == 2) {
            cout << "Node " << i << " has 2 adjacent nodes." << endl;
        }
        else if (nodes[i].adj.size() == 3) {
            cout << "Node " << i << " has 3 adjacent nodes." << endl;
        }
    }
}

int main() {
    vector<Node> nodes = read_ply_file("test.ply");
    vector<Edge> mst = minimum_spanning_tree(nodes);
    classify_nodes(nodes);
    return 0;
}
``