图的存储

参考链接：https://www.cnblogs.com/Kohinur/p/8947142.html

链式前向星

#include<iostream>
#include<string.h>
#include<queue>
using namespace std;
#define MAXN 100501
struct NODE{
    int next;//与第i条边同起点的下一条边的位置
    int v;//第i条边的终点
    int w;//第i条边的边权
}edge[MAXN];
int cnt;//内存计数器
int head[MAXN];
bool visdfs[MAXN];
bool visbfs[MAXN];
void add(int u,int v,int w){
    edge[cnt].w=w;
    edge[cnt].v=v;    //edge[i]表示第i条边的终点
    edge[cnt].next=head[u]; //head[i]表示以i为起点的最后一条边的储存位置
    head[u]=cnt++;
}
void DFS(int x)
{
    visdfs[x] = true;
    printf("%d
", x);
    for(int i = head[x]; i != 0; i = edge[i].next)
    {
        if(!visdfs[edge[i].v])
        {
            DFS(edge[i].v);
        }
    }
}
void BFS(int x)
{
    queue<int> q;
    q.push(x);
    visbfs[x] = true;//标记
    while (!q.empty()) {
        int i=q.front();
        q.pop();
        cout<<i<<endl;
        for(int k = head[i]; k != 0; k = edge[k].next)
        {
            if(!visbfs[edge[k].v])
            {
                visbfs[edge[k].v] = true; //标记
                q.push(edge[k].v);
            }
        }
    }
}
void BFS1(int x)
{
    int q[MAXN];//队列
    int jin = 0, chu = 0, st;
    q[jin++] = x;
    visbfs[x] = true;//标记
    while(chu < jin)
    {
        st = q[chu++];
        printf("%d
", st);
        for(int k = head[st]; k != 0; k = edge[k].next)
        {
            if(!visbfs[edge[k].v])
            {
                visbfs[edge[k].v] = true; //标记
                q[jin++] = edge[k].v;
            }
        }
    }
}

void Print()
{
    int k, i;
    for(i = 1; i <= 5; i++)
    {
        if(head[i])//找边
        {
            for(k = head[i]; k != 0; k = edge[k].next)
            {
                printf("%d->%d %d
", i, edge[k].v, edge[k].w);
            }
        }
    }
}
int main(){
    //init
    cnt=1;
    memset(head,0,sizeof(head));
    memset(visbfs, 0, sizeof(visbfs));
    memset(visdfs, 0, sizeof(visdfs));
    //一共有多少组数据
    int n;
    cin>>n;
    int a,b,c;
    while(n--){
        cin>>a>>b>>c;
        add(a,b,c);
    }
    //  Print();
    // DFS(1);
    BFS1(1);
    //访问某个点所有连接的点
    //    int start;
    //    cin>>start;
    //    for(int i=head[start];i!=0;i=edge[i].next)
    //        cout<<start<<"->"<<edge[i].v<<" "<<edge[i].w<<endl;
    return 0;
}
/*
7
1 2 1
2 3 1
3 4 1
1 3 1
4 1 1
1 5 1
4 5 1
*/

　vector存储

#include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
#include<string>
#include<cstdio>
#include<queue>
#include<cstdlib>
#define N 110
#define INF 0x3f3f3f3f
using namespace std;

int n,m;
bool visdfs[N];
bool visbfs[N];

struct node
{
    int d,w;
};//定义一个结构体来存储每个入度点以及对应边的权值
//比如边u->d,权值为w,node结构体存储的就是d以及w。
vector<node>v[N];

void DFS(int x)
{
    visdfs[x] = true;
    printf("%d
", x);
    vector<node> s=v[x];
    for(int i = 0; i <s.size(); i++)
    {
        if(!visdfs[s[i].d])
        {
            DFS(s[i].d);
        }
    }
}
void BFS(int x)
{
    queue<int> q;
    q.push(x);
    visbfs[x] = true;//标记
    while (!q.empty()) {
        int i=q.front();
        q.pop();
        cout<<i<<endl;
        vector<node> s=v[i];
        for(int k = 0; k <s.size(); k++)
        {
            if(!visbfs[s[k].d])
            {
                visbfs[s[k].d] = true; //标记
                q.push(s[k].d);
            }
        }
    }
}

int main()
{
    //对于N非常大但是M很小的这种稀疏图来说，用邻接矩阵N*N是存不下的。邻接矩阵是将所有的点都存储下来了，然而
    //对于稀疏图来说，有很多点是没有用到的，把这些点也存储下来的话就会很浪费空间。可以用邻接表来存储，这里借助vector来实现邻接表的操作。
    //用邻接表存储时候，只存储有用的点，对于没有用的点不存储，实现空间的优化。
    //n个点m条边
    memset(visdfs, 0, sizeof(visdfs));
    memset(visbfs,0,sizeof(visbfs));
    cin>>n>>m;
    int a,b,c;
    for(int i=0; i<=n; i++)
        v[i].clear();//将vecort数组清空
    for(int i=1; i<=m; i++) //用vector存储邻接表
    {
        node nd;
        scanf("%d%d%d",&a,&b,&c);
        nd.d=b,nd.w=c;//将入度的点和权值赋值给结构体
        v[a].push_back(nd);//将每一个从a出发能直接到达的点都压到下标为a的vector数组中，以后遍历从a能到达的点就可以直接遍历v[a]
        //        nd.d=a,nd.w=c;//无向图的双向存边
        //        v[b].push_back(nd);
    }
   // DFS(2);
    BFS(1);
    return 0;
}