请用c++写一个程序，使用贪心算法求解无向图的最小生成树，不使用向量

在C++中，我们可以使用Prim's算法（一种基于贪心策略的无向图最小生成树算法），而不使用向量数据结构。这里我们使用数组和邻接矩阵来表示图。以下是一个简单的Prim's算法实现：

#include <iostream>
#include <climits>

#define V 9 // 图的顶点数

// 边的数据结构
struct Edge {
    int src;
    int dest;
    int weight;
};

// 辅助函数：将边按照权重从小到大排序
bool compareEdges(const Edge &a, const Edge &b) {
    return a.weight < b.weight;
}

// Prim's算法实现
void primMST(int graph[V][V], int V) {
    bool marked[V] = {false}; // 标记已选取的顶点
    int mincost[V]; // 最小生成树的总权重
    for (int i = 0; i < V; i++) {
        mincost[i] = INT_MAX;
    }
    mincost[0] = 0;

    for (int count = 0; count < V - 1; count++) {
        int u = -1;
        for (int v = 0; v < V; v++) {
            if (!marked[v] && (u == -1 || mincost[u] > mincost[v])) {
                u = v;
            }
        }
        marked[u] = true;

        // 找出u到未标记节点中权重最小的边
        for (int v = 0; v < V; v++) {
            if (!marked[v] && graph[u][v] && mincost[u] + graph[u][v] < mincost[v]) {
                mincost[v] = mincost[u] + graph[u][v];
            }
        }
    }

    std::cout << "Minimum Spanning Tree with weights:\n";
    for (int i = 0; i < V; i++) {
        std::cout << "Edge from vertex " << i << " to ";
        for (int j = 0; j < V; j++) {
            if (graph[i][j] && !marked[j] && mincost[i] == graph[i][j]) {
                std::cout << j << " (" << mincost[i] << ") ";
            }
        }
        std::cout << "\n";
    }
}

int main() {
    Edge edges[] = {{0, 1, 4}, {0, 7, 8}, {1, 2, 8}, {1, 7, 11},
                   {2, 3, 7}, {2, 5, 4}, {3, 4, 9}, {3, 6, 2},
                   {4, 5, 14}, {5, 6, 10}, {6, 8, 2}, {7, 8, 7},
                   {7, 9, 15}, {8, 9, 10}, {8, 10, 1}, {9, 10, 6},
                   {9, 11, 3}, {10, 11, 7}};
    int num_edges = sizeof(edges) / sizeof(edges[0]);

    // 初始化邻接矩阵
    int graph[V][V];
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            graph[i][j] = edges[num_edges - 1]; // 使用最后一个边初始化，假设所有未连接的边权重最大
        }
    }

    // 设置实际的边权重
    for (auto edge : edges) {
        graph[edge.src][edge.dest] = edge.weight;
        graph[edge.dest][edge.src] = edge.weight;
    }

    primMST(graph, V);
    return 0;
}

这个程序首先创建了一个邻接矩阵，并在main函数中设置了一些边的权重。然后通过Prim's算法找到最小生成树并打印结果。