图

构造图(存储结构)

利用邻接矩阵

- 邻接矩阵——优点？

• • 直观、简单、好理解
• • 方便检查任意一对顶点间是否存在边
• • 方便找任一顶点的所有“邻接点”(有边直接相连的顶点）
• • 方便计算任一顶点的“度”

- 缺点:

• • 不便于增加和删除顶点
• • 浪费空间
• • 浪费时间(需要统计有多少边)

代码

#include<stdio.h>
#include<algorithm>
#include<cmath>
#include<iostream>
using namespace std;
#define MVNum 100
#define MaxInt 32767//极大值
typedef struct//最大顶点数
{
    int vexs[MVNum];//顶点表
    int arcs[MVNum][MVNum];//邻接矩阵
    int vexnum,arcnum;//图当前点数和边数
}AMGraph;
 
 
int LocateVex(AMGraph G,int u)
{
    int i;
    for(i=0;i<G.vexnum;i++)
    {
        if(u==G.vexs[i])  return i;
    }
    return -1;
}
//构造无向网
/*
无向图:
       1.初始化邻接矩阵时,w均为0;
       2.构造邻接矩阵时,w为1;
       ///或直接去掉权值w
 
有向网:
       (因为邻接矩阵为非对称矩阵,)
       仅向G.arc[i][j]赋值,不向G.arcs[j][i]赋值即可
有向图:
       ..........
*/
//初始化邻接矩阵
void Created(AMGraph &G)
{
     cin>>G.vexnum>>G.arcnum;
    int i;int j;
    for(i=0;i<G.vexnum;i++)
    {
        cin>>G.vexs[i];
    }
    for(i=0;i<G.vexnum;i++)
    {
        for(j=0;j<G.arcnum;j++)
        {
            G.arcs[i][j]=MaxInt;
        }
    }
    int v1,v2,w;
 
    int k;
    for(k=0;k<G.arcnum;k++)//构造邻接矩阵
    {
        cin>>v1>>v2>>w;//输入一条边的两顶点和权值
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
       G.arcs[j][i]=G.arcs[i][j]=w;
    }
}
 
 
int main()
{
    AMGraph G;
    Created(G);
 
 
return 0;
}
 

利用邻接表

特点

- 对于无向图

• • 邻接表不唯一
• • 若无向图有n个顶点,e条边,则邻接表需要n个头结点,2e个表节点.
• • 适宜稀疏图

- 对于有向图：

• • 找出度易:顶点v(i)的出度为第i个单链表中的结点个数。
• • 找出度难:需要全部遍历,顶点V的入度为整个单链表中邻接点域值是i-1的结点个数
• • 可以使用逆邻接表,则找出入度易,找出度难

代码

#include<stdio.h>
#include<algorithm>
#include<cmath>
#include<iostream>
using namespace std;
#define MVNum 100 //容量
#define MaxInt 32767//极大值
 
//弧(边)的结点定义
typedef struct ArcNode
{
    int adjvex;//该边所指向的顶点的位置
    struct ArcNode *nextarc;//指向下一条边的指针
//    Otherlnfo info;//和边相关的其他信息
}
ArcNode;
 
//顶点结构体
typedef struct VNode
{
    int data;//顶点信息
    ArcNode *firstarc;//指向第一条边的指针
}
VNode,AdjList[MVNum];//AdjList表示邻接表类型
/*
说明:AdjList v 等价于 VNode v[MVNum];
*/
 
//定义图
typedef struct
{
    AdjList vertices;//vertices--vertex的复数
    int vexnum,arcnum;//图的当前顶点数和弧数
}
ALGraph;
 
 
int LocateVex(ALGraph G,int k)
{
    int i;
    for(i=0;i<G.arcnum;i++)
    {
        if(G.vertices[i].data == k) return i;
    }
    return -1;
}
//采用邻接法表示法,创建无向网G
void CreateUDG (ALGraph &G)
{
    cin>>G.vexnum>>G.arcnum;//输入总顶点,总边数
 
    int i,j;
    for(i=0;i<G.vexnum ;i++)//建立表头节点表
    {
        cin>>G.vertices[i].data;//顶点值
        G.vertices[i].firstarc=NULL;//初始化指向的边
    }
    int v1,v2,k;
    for(k=0;k<G.arcnum ;k++)//输入边,构造邻接表
    {
        cin>>v1>>v2;//输入边,依附的两个顶点
        i=LocateVex(G,v1);//查找到顶点1位置
        j=LocateVex(G,v2);//查找到顶点2位置
 
       ArcNode *p1 = new ArcNode;//生成新的边结点
        p1->adjvex = j;//邻接序号为j;
        p1 -> nextarc = G.vertices[i].firstarc;
        G.vertices[i].firstarc=p1;//头插进顶点d边表头部
        
         ArcNode *p2 = new ArcNode;
        p1->adjvex =i;
        p1 -> nextarc = G.vertices[j].firstarc;
        G.vertices[j].firstarc=p1;
    }
}
int main()
{
    ALGraph G;
 
 
return 0;
}
 
 

区别邻接矩阵和邻接表

用途
邻接矩阵用于稠密图,邻接表用于稀疏图
联系

• 联系：邻接表中每个链表对应于邻接矩阵中的一行，链表中结点个数等于一行中非零元素的个数。
  区别
• 对于任一确定的无向图，邻接矩阵是唯一的(行列号与顶点编号一
  致)，
• • 但邻接表不唯一(链接次序与顶点编号无关）。
• 邻接矩阵的空间复杂度为O（n的2次幂），
• • 而邻接表的空间复杂度为o(n+e)。

十字链表和临接多重表

十字链表(用于有向图)

解决:邻接表求结点的度困难
方法:

• 顶点结点,增加一个指向 入度的指针
• 边结点,增加 入度顶点信息,
  

临接多重表(用于无向图)

解决:邻接表的而

实战

存储

邻接矩阵构建

//用c语言写，c++会超时

#include<stdio.h>
#include<iostream>
#include <string.h>
#include <stdbool.h>
 
using namespace std;
      bool a[5005][5005];
int main()
{
    int n,m, i, u,v, x,y, q;
  while(scanf("%d %d",&n,&m)!=EOF)
  {
      memset(a,0,sizeof(a));
 
        for(i=0; i<m; i++)
        {
            cin>>u>>v;
            a[u][v]=1;
        }
 
        cin>>q;
 
        for(i=0; i<q; i++)
        {
            cin>>x>>y;
            if(a[x][y]==1)
                cout<<"Yes"<<endl;
            else
                cout<<"No"<<endl;
        }
 
 
  }
    return 0;
}
 
 

邻接表存储

//用c语言写，c++会超时

#include<stdio.h>
#include<iostream>
#include <string.h>
#include <stdbool.h>
using namespace std;
 
struct node
{
    int data;
    struct node *next;
};
int main()
{
    int n,m;
   while(cin>>n>>m) 
   {
       
 
    int i,u,v;
    struct node *G[500001],*Q;
      for(i=0;i<n;i++)
      {
           G[i]=(struct node*)malloc(sizeof(struct node));
          G[i]->next=NULL;
          G[i]->data=-1;
      }
 
    for(i=0;i<m;i++)
    {
       cin>>u>>v;
       Q=(struct node*)malloc(sizeof(struct node));
       Q->data=v;
       Q->next=G[u]->next;
       G[u]->next=Q;
    }
 
    int p;
    cin>>p;
 
    int a,b;
    for(i=0;i<p;i++)
    {
       cin>>a>>b;
       Q=G[a];
 
    while(Q!=NULL)
       {
 
 
           if(Q->data==b)
           {
               cout<<"Yes"<<endl;
               break;
           }
           Q=Q->next;
       }
       if(Q==NULL)
       {
           cout <<"No"<<endl;
       }
    }
 
   }
 return 0;
}
### [图的基本存储的基本方式三](https://acm.sdut.edu.cn/onlinejudge3/problems/3118 "图的基本存储的基本方式三")

#include<stdio.h>
#include<iostream>
#include <string.h>
#include <stdbool.h>
using namespace std;
 
typedef struct
{
    int a=0;
    int b=0;
    int c=0;
 
}TU;
 
 
void q_sort(TU a[],int l,int r)//快速排序
{
 
    TU key=a[l];
    int i=l;
    int j=r;
    if(l>=r)
        return;
    while(i<j)
    {//权值w小的在前；
    //权值相等时出发点u小的在前；
    //权值和出发点相等时到达点v小的在前
        while(i<j &&(key.c<a[j].c
        ||(key.c==a[j].c&&key.a<a[j].a)
        ||(key.c==a[j].c&&key.a==a[j].a&&key.b<a[j].b)))
            j--;
        a[i]=a[j];
 
         while(i<j&&(key.c>a[i].c
        ||(key.c==a[i].c&&key.a>a[i].a)
        ||(key.c==a[i].c&&key.a==a[i].a&&key.b>a[i].b)))
            i++;
        a[j]=a[i];
    }
    a[i]=key;
    q_sort(a,l,i-1);
    q_sort(a,i+1,r);
}
int main()
{
    int n,m;
   while(cin>>n>>m)
   {
       TU G[m];
       int i;
       for(i=0;i<m;i++)
       {
        cin>>G[i].a>>G[i].b>>G[i].c;
       }
       //sort(G.c,G.c+m);
       q_sort(G,0,m-1);
 
 
 
       int q;
       cin>>q;
       int k;
       for(i=0;i<q;i++)
       {
           cin>>k;
           cout<<G[k].a<<" "<<G[k].b<<endl;
       }
   }
 return 0;
}
 

用邻接表

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct node
{
    int data;
    struct node *next;
}*a[5010];
void add(int i, int j)
{
    struct node *q;
    q  = (struct node *)malloc(sizeof(struct node));
    q->data = j;
    q->next = NULL;
    if(a[i] == NULL){
        a[i] = q;
    }else {
        q->next = a[i]->next;
        a[i]->next = q;
    }
}
int main()
{
    int n;
    while(~scanf("%d", &n)){
        int i, j;
        int x;
        int u, v;
        struct node *p;
        for(i = 0;i < n;i++){
            a[i] = NULL;
        }
        for(i = 0;i < n;i++){
            for(j = 0;j < n;j++){
                scanf("%d", &x);
                if(x == 1){
                    add(i,j);
                }
            }
        }
        int q;
        scanf("%d", &q);
        int flag;
        while(q--){
            scanf("%d %d", &u, &v);
            flag = 0;
            p = a[u];
            while(p){
                if(p->data == v){
                    flag = 1;
                    break;
                }
                p = p->next;
            }
            if(flag){
                printf("Yes\n");
            }else {
                printf("No\n");
            }
        }
    }
 
    return 0;
}