用广度优先遍历邻接表，却只能出现三个顶点

用广度优先遍历邻接表，却只能出现三个顶点，为啥？

以下是代码：

//图的邻接表存储定义
typedef struct ANode
{
    int adjvex;//该边的终点编号
    struct ANode* nextarc;//指向下一条边的指针
    InfoType weight;//该边的权值等信息
}ArcNode;

typedef char Vertex[10];
typedef struct Vnode
{
    Vertex data;//顶点信息
    ArcNode* firstarc;//指向第一条边
}VNode;

typedef struct
{
    VNode adjlist[MAXV];//邻接表
    int n1, e1;//顶点数n和边数e
}AdjGraph;
typedef struct
{
    int data[MAXV];//存放队中元素
    int front, rear;//队头、队尾指针
}SqQueue;
//初始化邻接表
void InitALGraph(AdjGraph* A)
{
    A = (AdjGraph*)malloc(sizeof(AdjGraph));
    A->n1 = 0;
    A->e1 = 0;
}
//建立邻接表AdjGraph
void CreateALGraph(AdjGraph*& A)
{
    A = (AdjGraph*)malloc(sizeof(AdjGraph));
    int i, j = 0,w=0;
    ArcNode* L=0;
    cout << "请输入顶点数和边数：";
    cin >> A->n1 >> A->e1;
    //cout << "输入顶点信息（A B C...）：";
    for (i = 0; i < A->n1; i++)
    {
        //cin >> A->adjlist[i].data;//输入顶点信息
        A->adjlist[i].firstarc = 0;//将邻接表初始化
    }
    cout << "输入边（vi,vj）上的顶点序号以及权值：";
    for (int k = 0; k < A->e1; k++)
    {
        
        cin >> i >> j>>w;
        L = (ArcNode*)malloc(sizeof(ArcNode));
        L->adjvex = j;//边的终点编号
        L->nextarc = A->adjlist[i].firstarc;
        L->weight = w;
        A->adjlist[i].firstarc = L;//将当前顶点的指针指向L

        L = (ArcNode*)malloc(sizeof(ArcNode));
        L->adjvex = i;
        L->nextarc = A->adjlist[j].firstarc;
        L->weight = w;
        A->adjlist[j].firstarc = L;
    }
    cout <<endl;
    DispALGraph(A,L);
}
//输出邻接表
void DispALGraph(AdjGraph* A,ArcNode*L)//
{
    cout << "图的邻接表：" << endl;

    for (int i = 0; i < A->n1; i++)
    {
        L = A->adjlist[i].firstarc;
        cout << i << "  ";
        while (L)
        {
            cout << "→" << L->adjvex << "  " << L->weight<<"（权重）";
            L = L->nextarc;
        }
        cout << endl;
    }
}
//初始化队列
void InitQueue(SqQueue*& qu)
{
    qu = (SqQueue*)malloc(sizeof(SqQueue));
    qu->front = 0;
    qu->rear = 0;
}

//入队
bool enQueue(SqQueue*& qu,int e)
{
    if ((qu->rear+1)%MAXV==qu->front)
        return false;
    
    qu->data[qu->rear] = e;//rear位置插入元素
    qu->rear = (qu->rear + 1) % MAXV;
    return true;
}
//出队
bool deQueue(SqQueue*& qu, int e)
{
    if (qu->rear == qu->front)//队空
        return false;
    e = qu->data[qu->front];
        qu->front = (qu->front + 1) % MAXV;

    return true;
}
//判断队列空
bool QueueEmpty(SqQueue*& qu)
{
    if (qu->front == qu->rear)
        return true;
    return false;
}
int _visited[20] = { 0 };

//广度优先遍历
void BFS(AdjGraph* A, int v)
{

    int w = 0,j=0;
    ArcNode* p;
    SqQueue* qu;//定义队列指针
    InitQueue(qu);//初始化队列
    cout << v << " ";
    _visited[v] = 1;
    enQueue(qu, v);//v入队
    while (!QueueEmpty(qu))
    {
        deQueue(qu, w);//出队一个顶点w
        p = A->adjlist[w].firstarc;//指向w第一个邻接点
        while (p!=NULL)
        {
            //j = p->adjvex;
            if (_visited[p->adjvex] == 0)//当前结点未被访问
            {
                cout << p->adjvex<<" ";//访问该邻接点
                _visited[p->adjvex] = 1;//标记已访问
                enQueue(qu, p->adjvex);//该顶点进队
            }
            p=p->nextarc;
        }
    }
    cout << endl;
}
int main()
{
    AdjGraph* A=0;
    InitALGraph(A);
    CreateALGraph(A);
    cout << "广度优先遍历：";
    BFS(A, 0);
    
}

如果只能出现三个顶点，则可能是遍历过程出了问题。
在广度优先遍历中，需要使用队列来存储遍历的顶点。首先将起点放入队列，然后开始遍历。每次从队列中取出一个顶点，如果它还未被访问过，则将它标记为已访问，并将它的所有邻接顶点放入队列。这样，每个顶点只会被遍历一次，直到遍历完整个图为止。
如果只能出现三个顶点，可能是由于队列未能正确存储遍历过程中的顶点导致的。可以检查队列的存储方式是否正确，确保队列能够按照正确的顺序存储顶点。
另外，也可以检查遍历过程中的访问标记是否正确，确保每个顶点只被遍历一次，避免重复遍历。