在MAIN 函数附件发现未处理的异常怎么办

Question

#include<stdio.h>
#include<iostream>
#define MAX_VERTEX_NUM 30
#define INF 32767
#define MAX 999
typedef int elemtype;
using namespace std;
typedef struct {
    elemtype data[MAX];
    int top;
}stack;//栈！
void initstack(stack*& s) {
    s = (stack*)malloc(sizeof(stack));
    s->top = -1;
}
bool stackempty(stack* s) {
    return(s->top == -1);
}
bool push(stack*& s, elemtype e) {
    if (s->top == MAX - 1)return false;
    s->top++;
    s->data[s->top] = e;
    return true;
}
bool pop(stack*& s, elemtype& e) {
    if (s->top == -1)return false;
    e = s->data[s->top];
    s->top--; return true;
}//出栈
typedef struct ArcNode
{
    int adjvex;//该边的邻接点编号
    struct ArcNode* nextarc;//指向下一条边
    int weight;
}ArcNode;//边节点的类型
typedef struct VNode
{
    char data;
    struct ArcNode* firstarc;//指向第一个边结点
}VNode;
typedef struct
{
    VNode adjlist[MAX_VERTEX_NUM];
    int n, e;//顶点数和边数
}AdjGraph;
//采用邻接表表示法建立无向图G
void CreateAdj(AdjGraph*& G, int A[MAX][MAX], int n, int e) {
    int i, j; ArcNode* p;
    G = (AdjGraph*)malloc(sizeof(AdjGraph));
    for (i = 0; i < n; i++) G->adjlist[i].firstarc = NULL;
    for (i = 0; i < n; i++) {
        for (j = n - 1; j >= 0; j--) {
            if (A[i][j] != 0 && A[i][j] != INF) {
                p = (ArcNode*)malloc(sizeof(ArcNode));
                p->adjvex = j;
                p->weight = A[i][j];
                p->nextarc = G->adjlist[i].firstarc;
                G->adjlist[i].firstarc = p;//头插法
            }
        }
    }
    G->n = n; G->e = e;
}

//广度优先遍历的非递归算法
void stackBFS(AdjGraph* G, int v)
{
    ArcNode* p;
    int n = G->n;
    int visited[MAX];
    for (int i = 0; i < G->n; i++)visited[i] = 0;
    printf("%d\t", v);
    stack* s1, * s2;//入栈和出栈
    initstack(s1); initstack(s2);
    push(s1, v);
    int t1[MAX];
    int t2[MAX];
    while (!stackempty(s1)) {
        for (int i1 = 0; i1 <= G->n; i1++) t1[i1] = -1;//用数组t储存出栈入栈的数据
        int i2 = 0; int i3 = 0;
        while (!stackempty(s1))
        {
            for (int i2 = 0; i2 <= G->n; i2++) t2[i2] = -1;//在这个循环里设定数组t2的初始值
            pop(s1, t1[i2]); push(s2, t1[i2]); pop(s2, t1[i2]); i2++;//从 入栈 出栈，再从 出栈 进栈，出栈以此来模拟队列
            p = G->adjlist[t1[i2]].firstarc;
            while (p != NULL) {
                if (visited[p->adjvex] == 0) {
                    printf("%d", p->adjvex);
                    visited[p->adjvex] = 0;
                    t2[i3] = p->adjvex;
                    i3++;
                }
                p = p->nextarc;
            }//从p开始直到边结点为空,输出的同时把边结点进栈，这里先把这些顶点储存起来
            for (; i3 > 0; i3--)
                push(s1, t2[i3]);

        }
    }
}
int main() {
    int a[MAX][MAX] = {
        {0,1,1,1,INF,INF,INF},
        {1,0,INF,INF,1,INF,INF},
        {1,INF,0,INF,1,1,INF},
        {1,INF,INF,0,INF,1,1},
        {INF,1,1,INF,0,1,INF},
        {INF,INF,1,1,INF,0,1},
        {INF,INF,INF,1,1,1,0}
    };
    AdjGraph* G;
    int v;
    CreateAdj(G, a, 7, 11);
    printf("输入起始点序号：");
    cin >> v;
    printf("广度优先遍历序列为：");
    stackBFS(G, v);
}

Answer 1

以下内容由CHATGPT及阿里嘎多学长共同生成、有用望采纳：

---

根据你提供的代码和异常信息，我们可以逐步分析问题并尝试找到解决方案。

异常信息分析

异常信息提示栈溢出（Stack overflow），这通常发生在递归调用过深或循环中不断增加栈的使用而没有适当减少时。在你的代码中，stackBFS函数中存在一个潜在的无限循环，这可能是导致栈溢出的原因。

stackBFS函数分析

在stackBFS函数中，你试图使用两个栈s1和s2来模拟队列的行为进行广度优先搜索。但是，存在几个问题：

1. 循环条件错误：while (!stackempty(s1))循环的条件是正确的，但是内部的循环逻辑存在问题。特别是，pop(s1, t1[i2]); push(s2, t1[i2]); pop(s2, t1[i2]);这部分代码会导致i2的值不断增加，而没有正确地处理数组t1和t2。
2. 数组索引越界：for (int i1 = 0; i1 <= G->n; i1++)和for (int i2 = 0; i2 <= G->n; i2++)中的i1和i2应该小于G->n，而不是G->n或G->n + 1，因为这会导致数组越界。

修复建议

1. 修复循环逻辑：你需要确保在处理栈时，正确地使用数组t1和t2来模拟队列的行为。同时，确保循环条件正确，避免无限循环。
2. 检查数组索引：确保在使用数组时，索引不会超过数组的大小。
3. 添加边界检查：在CreateAdj函数中，确保邻接矩阵A的值在创建邻接表时是有效的，避免创建无效的边。

代码示例修复

以下是对stackBFS函数的一些可能的修复：

void stackBFS(AdjGraph* G, int v) {
    ArcNode* p;
    int n = G->n;
    int visited[MAX] = {0}; // 初始化访问数组
    stack* s1, *s2;
    initstack(s1); initstack(s2);
    push(s1, v);
    visited[v] = 1; // 标记起始顶点为已访问

    while (!stackempty(s1)) {
        int u;
        pop(s1, u); // 从栈中取出顶点
        printf("%d ", u); // 打印顶点

        p = G->adjlist[u].firstarc;
        while (p != NULL) {
            int adjV = p->adjvex;
            if (!visited[adjV]) {
                visited[adjV] = 1; // 标记邻接顶点为已访问
                push(s2, adjV); // 将邻接顶点压入辅助栈
            }
            p = p->nextarc;
        }

        // 将辅助栈中的所有顶点压回主栈
        while (!stackempty(s2)) {
            pop(s2, u);
            push(s1, u);
        }
    }
}

总结

修复上述问题后，你的程序应该能够避免栈溢出异常。同时，确保在编写代码时，对边界条件和数组索引进行适当的检查，以避免潜在的错误。

由于你没有提供具体的参考链接，我无法列出。但是，如果你需要进一步的帮助或有其他问题，请随时告诉我。