图的基本操作

1.邻接矩阵存图
#include<bits/stdc++.h>
using namespace std;
#define maxn 32767
#define maxv 100
#define OK 1
//邻接矩阵的定义
typedef struct
{
    char vexs[maxv];
    int arcs[maxv][maxv];
    int vexnum;
    int arcnum;
}amgraph;
//确定顶点表的位置
int Loated(amgraph G,char u)
{
    for(int i=0;i<G.vexnum;i++)
    {
        if(u==G.vexs[i])
        {
            return i;
        }

    }
    return -1;
}
//创建邻接矩阵
int Createudn(amgraph &G)
{
    char s,e;
    int w;
    cout<<"请输入点数和边数"<<endl;
    cin>>G.vexnum>>G.arcnum;
     cout<<"请输入每一个点"<<endl;
    for(int i=0;i<G.vexnum;i++)
    {
        cin>>G.vexs[i];
    }
    for(int i=0;i<G.vexnum;i++)
    {
        for(int j=0;j<G.vexnum;j++)
        {
            G.arcs[i][j]=maxn;
        }
    }
    cout<<"请输入每一条边"<<endl;
    for(int i=0;i<G.arcnum;i++)
    {
        cin>>s>>e>>w;
        int a=Loated(G,s);
        int b=Loated(G,e);
        G.arcs[a][b]=G.arcs[b][a]=w;
    }
    return OK;
}
int main()
{
    amgraph G;
    cout<<"创建邻接矩阵"<<endl;
    Createudn(G);
    cout<<"邻接矩阵创建完成"<<endl;
}

 

 

 

2.邻接表存图
#include<bits/stdc++.h>
using namespace std;
#define maxv 100
#define OK 1
//边节点
typedef struct Arcnode
{
    int adjvex;//上一条边
    struct Arcnode *nextarc;//下一条边
    int info;//权值
}Arcnode;
//顶点
typedef struct Vnode
{
    char data;//名称
    Arcnode *fiestarc;//第一个节点
}Vnode,Adjlist[maxv];
//定义邻接表
typedef struct
{
    Adjlist vertices;//表头
    int vexnum;//最大点数
    int arcnum;//最大边数
}Algragh;
//确定表头位置
int Located(Algragh G,char u)
{
    for(int i=0;i<G.vexnum;i++)
    {
        if(u==G.vertices[i].data)
            return i;
    }
    return -1;
}
int Createuec(Algragh G)
{
    char s,e;
    int w;
    cout<<"请输入最大点数和最大边数"<<endl;
    cin>>G.vexnum>>G.arcnum;
    cout<<"请输入每个点"<<endl;
    for(int i=0;i<G.vexnum;i++)
    {
        cin>>G.vertices[i].data;
        G.vertices[i].fiestarc=NULL;
    }
    cout<<"请输入每条边"<<endl;
    for(int i=0;i<G.arcnum;i++)
    {
        cin>>s>>e>>w;
        int a=Located(G,s);
        int b=Located(G,e);
        Arcnode *p1=new Arcnode;
        p1->adjvex=b;
        p1->info=w;
        p1->nextarc=G.vertices[a].fiestarc;
        G.vertices[a].fiestarc=p1;
        Arcnode *p2=new Arcnode;
        p2->adjvex=a;
        p2->info=w;
        p2->nextarc=G.vertices[a].fiestarc;
        G.vertices[a].fiestarc=p2;
    }
    return OK;
}
int main()
{
    Algragh G;
    cout<<"创建邻接表"<<endl;
    Createuec(G);
    cout<<"邻接表创建完成"<<endl;
}

 

 

 

#include<bits/stdc++.h>
using namespace std;
#define maxn 32767
#define maxv 100
#define OK 1
#define ERROR -1 
bool visited[1000];
//邻接矩阵的定义
typedef struct
{
    char vexs[maxv];//存储顶点 
    int arcs[maxv][maxv];//存储边 
    int vexnum;//最大顶点数 
    int arcnum;//最大边数 
}amgraph;
//确定顶点表的位置
int Loated(amgraph G,char u)
{
    for(int i=0;i<G.vexnum;i++)
    {
        if(u==G.vexs[i])
        {
            return i;
        }

    }
    return -1;
}
//创建邻接矩阵
int Createudn(amgraph &G)
{
    char s,e;
    int w;
    cout<<"请输入点数和边数"<<endl;
    cin>>G.vexnum>>G.arcnum;
     cout<<"请输入每一个点"<<endl;
    for(int i=0;i<G.vexnum;i++)
    {
        cin>>G.vexs[i];
    }
    for(int i=0;i<G.vexnum;i++)
    {
        for(int j=0;j<G.vexnum;j++)
        {
            G.arcs[i][j]=maxn;
        }
    }
    cout<<"请输入每一条边"<<endl;
    for(int i=0;i<G.arcnum;i++)
    {
        cin>>s>>e>>w;
        int a=Loated(G,s);
        int b=Loated(G,e);
        G.arcs[a][b]=G.arcs[b][a]=w;
    }
    return OK;
}
//深度优先搜索遍历
void dfs(amgraph G,int v)
{
    cout<<G.vexs[v]<<endl;
    visited[v]=true;
    for(int w=0;w<G.vexnum;w++)
    {
        if(G.arcs[v][w]!=0&&(!visited[w]))
            dfs(G,w);
    }
}
//队列
typedef struct
{
    int *base;
    int front;
    int rear;
 }Squeue;
//新建空队列
int InitQueue(Squeue &Q)
{
    Q.base=new int[maxv];
    if(!Q.base)
    exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
 } 
 //入队
 int Enqueue(Squeue &Q,int e)
 {
     if((Q.rear+1)%maxv==Q.front)
     return ERROR;
     Q.base[Q.rear]=e;
     Q.rear=(Q.rear+1)%maxv;
     return OK;
  } 
  //出队
  int Dequeue(Squeue &Q,int &e)
  {
      if(Q.front==Q.rear)
      return ERROR;
      e=Q.base[Q.front];
      Q.front=(Q.front+1)%maxv;
      return OK;
   } 
   //是否队空
   int Queueempty(Squeue &Q)
   {
       if(Q.rear==Q.front)
       return 1;
       else
       return 0;
    } 
int First(amgraph G,int u)
{
    for(int i=0;i<G.vexnum;i++)
    {
        if(G.arcs[u][i]!=32767)
        return i;
    }
    return -1;
}
int Next(amgraph G,int u,int w)
{
    for(int i=w+1;i<G.vexnum;i++)
    {
        if(G.arcs[u][i]!=32767)
        return i;
    }
    return -1;
}
//bfs
void bfs(amgraph G,int v)
{
    int u;
    cout<<G.vexs[v]<<endl;
    visited[v]=true;
    Squeue Q;
    InitQueue(Q);
    Enqueue(Q,v);
    while(!Queueempty(Q))
    {
        Dequeue(Q,u);
        for(int w=First(G,u);w>=0;w=Next(G,u,w))
        {
            if(!visited[w])
            {
                cout<<G.vexs[w]<<endl;
                visited[w]=true;
                Enqueue(Q,w);
            }
        }
    }
}
int main()
{
    amgraph G;
    int a;
    cout<<"1.创建邻接矩阵"<<endl;
    cout<<"2.广度优先遍历邻接矩阵"<<endl;
    cout<<"3.深度优先遍历邻接矩阵"<<endl;
    cout<<"请选择您的操作（按0结束操作）"<<endl;
    while(cin>>a,a)
    {
         switch(a)
    {
        case 1:cout<<"创建邻接矩阵"<<endl;
             Createudn(G);
             cout<<"邻接矩阵创建完成"<<endl;
             break;
        case 2:cout<<"广度优先遍历邻接矩阵"<<endl;
            bfs(G,0); 
            fill(visited,visited+1000,false);
            break;
        case 3:cout<<"深度优先遍历邻接矩阵"<<endl;
            dfs(G,0);
            fill(visited,visited+1000,false);
            break;
    }
    cout<<"1.创建邻接矩阵"<<endl;
    cout<<"2.广度优先遍历邻接矩阵"<<endl;
    cout<<"3.深度优先遍历邻接矩阵"<<endl;
    cout<<"请选择您的操作（按0结束操作）"<<endl;
    }
}