C++ 大数据集dijkstra计算期间的错误分配

我正在尝试用dijkstra算法求解大图的最短路径。 问题是，当我在CLion中执行程序时，我得到的是std:：bad alloc，总是在节点491，然而当我在我的Ubuntu VM上尝试做同样的事情时，我得到的内核被转储到了服务器上

我对C++很陌生，所以很难理解为什么会发生这种情况。 这是我的密码：

UTIL：

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <sstream>
#include <ctime>

#define INFINITY 9999999

int maxNode = 0;
using namespace std;

vector<int> loadFile(const string &path) {
    vector<int> graph;
    ifstream file;
    file.open(path);
    if (!file.fail()) {
        string line;
        while (getline(file, line)) {
            stringstream ss(line);
            for (int i; ss >> i;) {
                if (i + 1 > maxNode)
                    maxNode = i + 1;
                graph.push_back(i);
                if (ss.peek() == ';')
                    ss.ignore();
            }
        }
        file.close();
    }
    return graph;
}

int **formatGraph(vector<int> inData) {
    int **graph = 0;
    int currentIndex = 0;
    int srcNode = inData[0];
    int dstNode = inData[1];
    int cost = inData[2];
    graph = new int *[maxNode];
    for (int i = 0; i < maxNode; i++) {
        graph[i] = new int[maxNode];
        for (int j = 0; j < maxNode; j++) {
            if (srcNode == i && dstNode == j) {
                graph[i][j] = cost;
                currentIndex++;
                srcNode = inData[currentIndex * 3];
                dstNode = inData[currentIndex * 3 + 1];
                cost = inData[currentIndex * 3 + 2];
                //printf("%d %d\n", i, j);
            } else
                graph[i][j] = 0;
        }
    }
    for (int i = 0; i < maxNode; i++) {
        for (int j = 0; j < maxNode; j++) {
            graph[j][i] = graph[i][j];
        }
    }
    return graph;
}

#包括
#包括
#包括
#包括
#包括
#包括
#定义无限999999
int maxNode=0；
使用名称空间std；
矢量加载文件（常量字符串和路径）{
矢量图；
ifstream文件；
打开（路径）；
如果（！file.fail（））{
弦线；
while（getline（文件，行））{
弦流ss（线）；
对于（int i；ss>>i；）{
如果（i+1>maxNode）
maxNode=i+1；
图.推回（i）；
如果（ss.peek（）=='；'）
忽略（）；
}
}
file.close（）；
}
返回图；
}
int**格式图（矢量inData）{
int**graph=0；
int currentIndex=0；
int srcNode=inData[0]；
int-dstNode=inData[1]；
国际成本=国际数据[2]；
图形=新整数*[maxNode]；
对于（int i=0；i

算法：

void dijkstra(int **G, int n, int startnode) {
    printf("%d\n", startnode);
    int **cost = new int *[maxNode];
    int distance[maxNode], pred[maxNode];
    int visited[maxNode], count, mindistance, nextnode, i, j;
    for (i = 0; i < n; i++) {
        cost[i] = new int[maxNode];
        for (j = 0; j < n; j++)
            cost[i][j] = 0;
    }
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            if (G[i][j] == 0)
                cost[i][j] = INFINITY;
            else
                cost[i][j] = G[i][j];
    for (i = 0; i < n; i++) {
        distance[i] = cost[startnode][i];
        pred[i] = startnode;
        visited[i] = 0;
    }
    distance[startnode] = 0;
    visited[startnode] = 1;
    count = 1;
    while (count < n - 1) {
        mindistance = INFINITY;
        for (i = 0; i < n; i++) {
            if (distance[i] < mindistance && !visited[i]) {
                mindistance = distance[i];
                nextnode = i;
            }
        }
        visited[nextnode] = 1;
        for (i = 0; i < n; i++) {
            if (!visited[i]) {
                if (mindistance + cost[nextnode][i] < distance[i]) {
                    distance[i] = mindistance + cost[nextnode][i];
                    pred[i] = nextnode;
                }
            }
        }
        count++;
    }
    delete[] cost;
    for (i = 0; i < n; i++)
        if (i != startnode) {
            j = i;
            do {
                j = pred[j];
            } while (j != startnode);
        }
}

void dijkstra（int**G，int n，int startnode）{
printf（“%d\n”，startnode）；
整数**成本=新整数*[maxNode]；
整数距离[maxNode]，pred[maxNode]；
int访问[maxNode]，计数，MindDistance，nextnode，i，j；
对于（i=0；i

这是我的主要功能：

int main() {
    vector<int> graph = loadFile("..\\data\\newFile2.csv");
    int **graphConverted = formatGraph(graph);
    //printMatrix(graphConverted);
    clock_t begin = clock();
    for (int i = 0; i < maxNode; i++)
        dijkstra(graphConverted, maxNode, i);
    clock_t end = clock();
    double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
    printf("\nTime: %f", elapsed_secs);
    return 0;
}

delete[] cost;

intmain（）{
矢量图=加载文件（“..\\data\\newFile2.csv”）；
int**graphConverted=formatGraph（图形）；
//打印矩阵（图形转换）；
时钟开始=时钟（）；
对于（int i=0；i

首先将数据加载到向量中，然后将其转换为邻接矩阵。 数据以以下形式存储：

src_节点；dst_节点；成本
1.2.3
1.3.30
1.66;20
等等

数据集由1004个节点和25571条边组成

---

您能为我提供解决方案吗？

在dijkstra中，您有动态内存分配：

int **cost = new int *[maxNode];

这里是

i

上的一个循环：

cost[i] = new int[maxNode];

在此函数中，您只有一个对

delete[]

的调用：

int main() {
    vector<int> graph = loadFile("..\\data\\newFile2.csv");
    int **graphConverted = formatGraph(graph);
    //printMatrix(graphConverted);
    clock_t begin = clock();
    for (int i = 0; i < maxNode; i++)
        dijkstra(graphConverted, maxNode, i);
    clock_t end = clock();
    double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
    printf("\nTime: %f", elapsed_secs);
    return 0;
}

delete[] cost;

因此，来自第二个

新
行的所有分配都保证会泄漏。一段时间后，您的内存将不足，导致
std:：bad\u alloc

您需要将每个
new[]
调用与一个
delete[]
调用匹配


根本不要使用
new
/
delete
。相反，将所有数组声明为
std:：vector
，它将自动处理此问题

也不要使用可变长度数组，例如

int distance[maxNode], pred[maxNode];

它们是非标准编译器扩展。同时制作这些
std:：vector
。
在
dijkstra
中，这里有动态内存分配：

int **cost = new int *[maxNode];

这里是
i
上的一个循环：

cost[i] = new int[maxNode];

在此函数中，您只有一个对
delete[]
的调用：

int main() {
    vector<int> graph = loadFile("..\\data\\newFile2.csv");
    int **graphConverted = formatGraph(graph);
    //printMatrix(graphConverted);
    clock_t begin = clock();
    for (int i = 0; i < maxNode; i++)
        dijkstra(graphConverted, maxNode, i);
    clock_t end = clock();
    double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
    printf("\nTime: %f", elapsed_secs);
    return 0;
}

delete[] cost;

因此，来自第二个
新
行的所有分配都保证会泄漏。一段时间后，您的内存将不足，导致
std:：bad\u alloc

您需要将每个
new[]
调用与一个
delete[]
调用匹配


根本不要使用
new
/
delete
。相反，将所有数组声明为
std:：vector
，它将自动处理此问题

也不要使用可变长度数组，例如

int distance[maxNode], pred[maxNode];

它们是非标准编译器扩展。把这些
std:：vector
也做成。
我宁愿留在指针上，它在MPI中是并行的，所以我更容易在指针上操作。我