图的深度优先和广度优先遍历

         以邻接矩阵的方式给出一张图，输出深度优先（DFS）和广度优先（BFS）遍历结果。

将邻接矩阵转化为邻接表的形式存储。

​
#include <iostream>
using namespace std;

class NODE
{
    int data;
    NODE* next;
public:
    NODE(int data=0)
    {
        this->data=data;
        this->next=nullptr;
    }
    friend class LIST;
    friend class QUEUE;
};
class QUEUE
{
    int num;
    int maxnum;
    int first;
    int last;
    NODE** data;
public:
    QUEUE(int num)
    {
        this->maxnum=num;
        this->num=0;
        this->first=0;
        this->last=0;
        data=new NODE*[num];
    }
    bool isfull()
    {
        return maxnum==num;
    }
    bool isempty()
    {
        return num==0;
    }
    void push(NODE* p)
    {
        if(isfull())return;
        data[last]=p;
        last++;
        num++;
    }
    NODE* pop()
    {
        if(isempty())return nullptr;
        num--;
        cout << data[first]->data << " ";
        return data[first++];
    }
    void print()
    {
        for(int i=0;i<num;i++)
        {
            cout << data[i]->data << " ";
        }
        cout << endl;
    }
    friend class LIST;
};

class LIST
{
    int num;
    NODE** dot;
public:
    LIST(int num=0,int** l=nullptr)
    {
        this->num=num;
        this->dot=new NODE*[num];
        for(int i=0;i<num;i++){
            dot[i]=new NODE(i);
            NODE* p=dot[i];
            for(int j=0;j<num;j++){
                if(l[i][j]==1&&i!=j){
                    NODE* q=new NODE(j);
                    p->next=q;
                    p=p->next;
                }
            }
        }
    }
    void DFS(int start,int* visited)
    {
        cout << dot[start]->data << " ";
        visited[start]=1;
        NODE* p=dot[start]->next;
        while(p){
            if(visited[p->data]!=1){
                DFS(p->data,visited);
            }
            p=p->next;
        }
    }
    void DFSprint()
    {
        cout << "DFS" << endl;
        for(int i=0;i<num;i++){
            int* visited=new int[num];
            DFS(i,visited);
            cout << endl;
        }
    }
    void BFS(int start)
    {
        int* visited=new int[num];
        QUEUE que(num);
        que.push(dot[start]);
        visited[start]=1;
        while(!que.isempty())
        {

            NODE* p=que.pop();
            while(p->next!=nullptr)
            {
                if(visited[p->next->data]==0)
                {
                    que.push(dot[p->next->data]);
                    visited[p->next->data]=1;
                }
                p=p->next;
            }
        }
    }
    void BFSprint()
    {
        cout << "WFS" << endl;
        for(int i=0;i<num;i++)
        {
            BFS(i);
            cout << endl;
        }
    }
};

int main()
{
    int n;
    int** l;
    cin >> n;
    l=new int*[n];
    for(int i=0;i<n;i++){
        l[i]=new int[n];
        for(int j=0;j<n;j++){
            cin >> l[i][j];
        }
    }
    LIST a(n,l);
    a.DFSprint();
    a.BFSprint();
    return 0;
}

​