第6章课后习题算法设计题（严蔚敏数据结构c语言版第2版）

最新推荐文章于 2023-12-05 10:22:54 发布
最新推荐文章于 2023-12-05 10:22:54 发布
阅读量4k 收藏 51
点赞数 8
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42759593/article/details/110674683
版权

6-1 分别以邻接矩阵和邻接表作为存储结构，实现以下图的基本操作：
①增加一个新顶点v，InsertVex（G,v）
②删除顶点v及其相关的边，DeleteVex（G,v）
③增加一条边<v,w>，InsertArc（G,v,w）
④删除一条边<v,w>，DeleteArc（G,v,w）
（1）增加一个新顶点v，InsertVex（G,v）

#include <iostream>
using namespace std;
#define MaxInt 32767
#define MVNum 100
typedef struct{
    char vexs[MVNum];
    int arcs[MVNum][MVNum];
    int vexnum,arcnum;
}AMGraph;
typedef struct ArcNode{
    int adjvex;
    struct ArcNode * nextarc;
}ArcNode;
typedef struct VNode{
    char data;
    ArcNode *firstarc;
}VNode,AdjList[MVNum];
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;
void CreateUDN(AMGraph &G);
int LocateVex(AMGraph G,char v);
void CreateUDG(ALGraph &G);
int LocateVex(ALGraph G,char v);
void InsertVex(AMGraph &G,char v);
void InsertVex(ALGraph &G,char v);
int main(){
    AMGraph G1;
    ALGraph G2;
    char v;
    CreateUDN(G1);
//    InsertVex(G1,v);
    CreateUDG(G2);
    InsertVex(G2,v);
    return 0;
}
void CreateUDN(AMGraph &G){
    cout<<"-----邻接矩阵创建无向网-----"<<endl;
    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]=MaxInt;
        }
    }
    char v1,v2;
    int w,i,j;
    cout<<"输入一条边的2个顶点和权值："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2>>w;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        G.arcs[i][j]=w;
        G.arcs[j][i]=G.arcs[i][j];
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接矩阵为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        cout<<"[";
        for(int j=0;j<G.vexnum;j++){
            if(G.arcs[i][j]==32767)
                cout<<"* ";
            else
                cout<<G.arcs[i][j]<<" ";
        }
        cout<<"]"<<endl;
    }
}
int LocateVex(AMGraph G,char v){
    for(int i=0;i<G.vexnum;i++){
        if(v==G.vexs[i]){
            return i;
        }
    }
}
void CreateUDG(ALGraph &G){
    cout<<"-----邻接表创建无向网-----"<<endl;
    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].firstarc=NULL;
    }
    char v1,v2;
    int i,j;
    ArcNode *p1,*p2;
    cout<<"输入一条边的2个顶点："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        p1=new ArcNode;
        p1->adjvex=j;
        p1->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p1;
        p2=new ArcNode;
        p2->adjvex=i;
        p2->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p2;
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接表为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i<<"->";
        while(p!=NULL){
            cout<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}
int LocateVex(ALGraph G,char v){
     for(int i=0;i<G.vexnum;i++){
        if(v==G.vertices[i].data){
            return i;
        }
    }
}
void InsertVex(AMGraph &G,char v){
    cout<<"-----增加一个顶点-----"<<endl;
    cout<<"此时有"<<G.vexnum<<"个顶点"<<endl;
    cout<<"输入顶点数据："<<endl;
    G.vexnum++;
    cin>>G.vexs[G.vexnum-1];
    cout<<"增加成功"<<endl;
    cout<<"此时还剩"<<G.vexnum<<"个顶点"<<endl;
}
void InsertVex(ALGraph &G,char v){
    cout<<"-----增加一个顶点-----"<<endl;
    cout<<"此时有"<<G.vexnum<<"个顶点"<<endl;
    int data;
    cout<<"输入顶点数据："<<endl;
    cin>>data;
    G.vexnum++;
    G.vertices[G.vexnum-1].firstarc=NULL;
    G.vertices[G.vexnum-1].data=data;
    cout<<"增加成功"<<endl;
    cout<<"此时还剩"<<G.vexnum<<"个顶点"<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i;
        while(p!=NULL){
            cout<<"->"<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}

（2）删除顶点v及其相关的边，DeleteVex（G,v）

#include <iostream>
using namespace std;
#define MaxInt 32767
#define MVNum 100
typedef struct{
    char vexs[MVNum];
    int arcs[MVNum][MVNum];
    int vexnum,arcnum;
}AMGraph;
typedef struct ArcNode{
    int adjvex;
    struct ArcNode * nextarc;
}ArcNode;
typedef struct VNode{
    char data;
    ArcNode *firstarc;
}VNode,AdjList[MVNum];
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;
void CreateUDN(AMGraph &G);
int LocateVex(AMGraph G,char v);
void CreateUDG(ALGraph &G);
int LocateVex(ALGraph G,char v);
void DeleteVex(AMGraph &G,char v);
void DeleteVex(ALGraph &G,char v);
int main(){
    AMGraph G1;
    ALGraph G2;
    char v;
    CreateUDN(G1);
    //DeleteVex(G1,v);
    CreateUDG(G2);
    DeleteVex(G2,v);
    return 0;
}
void CreateUDN(AMGraph &G){
    cout<<"-----邻接矩阵创建无向网-----"<<endl;
    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]=MaxInt;
        }
    }
    char v1,v2;
    int w,i,j;
    cout<<"输入一条边的2个顶点和权值："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2>>w;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        G.arcs[i][j]=w;
        G.arcs[j][i]=G.arcs[i][j];
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接矩阵为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        cout<<"[";
        for(int j=0;j<G.vexnum;j++){
            if(G.arcs[i][j]==32767)
                cout<<"* ";
            else
                cout<<G.arcs[i][j]<<" ";
        }
        cout<<"]"<<endl;
    }
}
int LocateVex(AMGraph G,char v){
    for(int i=0;i<G.vexnum;i++){
        if(v==G.vexs[i]){
            return i;
        }
    }
}
void CreateUDG(ALGraph &G){
    cout<<"-----邻接表创建无向网-----"<<endl;
    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].firstarc=NULL;
    }
    char v1,v2;
    int i,j;
    ArcNode *p1,*p2;
    cout<<"输入一条边的2个顶点："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        p1=new ArcNode;
        p1->adjvex=j;
        p1->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p1;
        p2=new ArcNode;
        p2->adjvex=i;
        p2->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p2;
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接表为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i<<"->";
        while(p!=NULL){
            cout<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}
int LocateVex(ALGraph G,char v){
     for(int i=0;i<G.vexnum;i++){
        if(v==G.vertices[i].data){
            return i;
        }
    }
}
void DeleteVex(AMGraph &G,char v){
    cout<<"-----删除一个顶点和相关的边-----"<<endl;
    cout<<"此时有"<<G.vexnum<<"个顶点"<<endl;
    cout<<"输入顶点数据："<<endl;
    cin>>v;
    int temp;
    temp=LocateVex(G,v);
    if(temp!=G.vexnum-1){
        for(int i=0;i<G.vexnum-temp-1;i++){
            G.vexs[i+temp]=G.vexs[i+temp+1];
        }
        for(int i=0;i<G.vexnum;i++){
            for(int j=0;j<G.vexnum;j++){
                if(i==temp){
                G.arcs[i][j]=G.arcs[i+1][j];
            }else if(j==temp){
                G.arcs[i][j]=G.arcs[i][j+1];
            }
        }
        }
    }
    G.vexnum--;
    cout<<"删除成功"<<endl;
    cout<<"此时还剩"<<G.vexnum<<"个顶点"<<endl;
}
void DeleteVex(ALGraph &G,char v){
    cout<<"-----删除一个顶点和相关的边-----"<<endl;
    cout<<"此时有"<<G.vexnum<<"个顶点"<<endl;
    cout<<"输入顶点数据："<<endl;
    cin>>v;
    int temp;
    temp=LocateVex(G,v);
    ArcNode *p,*q;
    for(int i=0;i<G.vexnum;i++){
        //删除其他顶点与该顶点有关的边
        if(i!=temp){
            p=G.vertices[i].firstarc;
            q=p;
            while(p && p->adjvex!=temp){
                q=p;
                p=p->nextarc;
            }
            if(p && q==p){
                G.vertices[i].firstarc=p->nextarc;
            }else if(p){
                q->nextarc=p->nextarc;
            }
        }else{
        //删除顶点所在的边表行
            p=G.vertices[temp].firstarc;
            while(p){
                q=p->nextarc;
                delete p;
                p=q;
            }
        }
    }
    //删除顶点
    for(int i=temp;i<G.vexnum-1;i++){
        G.vertices[i]=G.vertices[i+1];
    }
    //改变邻接表其余顶点的下标
    for(int i=0;i<G.vexnum;i++){
        p=G.vertices[i].firstarc;
        while(p){
            if(p->adjvex>temp){
                p->adjvex--;
            }
            p=p->nextarc;
        }
    }
    G.vexnum--;
    cout<<"删除成功"<<endl;
    cout<<"此时还剩"<<G.vexnum<<"个顶点"<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i;
        while(p!=NULL){
            cout<<"->"<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}

（3）增加一条边<v,w>，InsertArc（G,v,w）

#include <iostream>
using namespace std;
#define MaxInt 32767
#define MVNum 100
typedef struct{
    char vexs[MVNum];
    int arcs[MVNum][MVNum];
    int vexnum,arcnum;
}AMGraph;
typedef struct ArcNode{
    int adjvex;
    struct ArcNode * nextarc;
}ArcNode;
typedef struct VNode{
    char data;
    ArcNode *firstarc;
}VNode,AdjList[MVNum];
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;
void CreateUDN(AMGraph &G);
int LocateVex(AMGraph G,char v);
void CreateUDG(ALGraph &G);
int LocateVex(ALGraph G,char v);
void InsertArc(AMGraph &G,char v,char w);
void InsertArc(ALGraph &G,char v,char w);
int main(){
    AMGraph G1;
    ALGraph G2;
    char v;
    char w;
    CreateUDN(G1);
    //InsertArc(G1,v,w);
    CreateUDG(G2);
    InsertArc(G2,v,w);
    return 0;
}
void CreateUDN(AMGraph &G){
    cout<<"-----邻接矩阵创建无向网-----"<<endl;
    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]=MaxInt;
        }
    }
    char v1,v2;
    int w,i,j;
    cout<<"输入一条边的2个顶点和权值："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2>>w;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        G.arcs[i][j]=w;
        G.arcs[j][i]=G.arcs[i][j];
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接矩阵为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        cout<<"[";
        for(int j=0;j<G.vexnum;j++){
            if(G.arcs[i][j]==32767)
                cout<<"* ";
            else
                cout<<G.arcs[i][j]<<" ";
        }
        cout<<"]"<<endl;
    }
}
int LocateVex(AMGraph G,char v){
    for(int i=0;i<G.vexnum;i++){
        if(v==G.vexs[i]){
            return i;
        }
    }
}
void CreateUDG(ALGraph &G){
    cout<<"-----邻接表创建无向网-----"<<endl;
    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].firstarc=NULL;
    }
    char v1,v2;
    int i,j;
    ArcNode *p1,*p2;
    cout<<"输入一条边的2个顶点："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        p1=new ArcNode;
        p1->adjvex=j;
        p1->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p1;
        p2=new ArcNode;
        p2->adjvex=i;
        p2->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p2;
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接表为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i<<"->";
        while(p!=NULL){
            cout<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}
int LocateVex(ALGraph G,char v){
     for(int i=0;i<G.vexnum;i++){
        if(v==G.vertices[i].data){
            return i;
        }
    }
}
void InsertArc(AMGraph &G,char v,char w){
    cout<<"-----增加一条边-----"<<endl;
    cout<<"此时有"<<G.arcnum<<"条边"<<endl;
    cout<<"输入两个顶点数据："<<endl;
    cin>>v>>w;
    int i,j,value;
    i=LocateVex(G,v);
    j=LocateVex(G,w);
    cout<<"输入边的权值："<<endl;
    cin>>value;
    G.arcs[i][j]=value;
    G.arcs[j][i]=value;
    G.arcnum++;
    cout<<"增加成功"<<endl;
    cout<<"此时还剩"<<G.arcnum<<"条边"<<endl;
}
void InsertArc(ALGraph &G,char v,char w){
    cout<<"-----增加一条边-----"<<endl;
    cout<<"此时有"<<G.arcnum<<"条边"<<endl;
    cout<<"输入两个顶点数据："<<endl;
    cin>>v>>w;
    int i,j;
    ArcNode *p1,*p2;
    i=LocateVex(G,v);
    j=LocateVex(G,w);
    p1=new ArcNode;
    p1->adjvex=j;
    p1->nextarc=G.vertices[i].firstarc;
    G.vertices[i].firstarc=p1;
    p2=new ArcNode;
    p2->adjvex=i;
    p2->nextarc=G.vertices[j].firstarc;
    G.vertices[j].firstarc=p2;
    G.arcnum++;
    cout<<"增加成功"<<endl;
    cout<<"此时还剩"<<G.arcnum<<"条边"<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i;
        while(p!=NULL){
            cout<<"->"<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}

（4）删除一条边<v,w>，DeleteArc（G,v,w）

#include <iostream>
using namespace std;
#define MaxInt 32767
#define MVNum 100
typedef struct{
    char vexs[MVNum];
    int arcs[MVNum][MVNum];
    int vexnum,arcnum;
}AMGraph;
typedef struct ArcNode{
    int adjvex;
    struct ArcNode * nextarc;
}ArcNode;
typedef struct VNode{
    char data;
    ArcNode *firstarc;
}VNode,AdjList[MVNum];
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;
void CreateUDN(AMGraph &G);
int LocateVex(AMGraph G,char v);
void CreateUDG(ALGraph &G);
int LocateVex(ALGraph G,char v);
void DeleteArc(AMGraph &G,char v,char w);
void DeleteArc(ALGraph &G,char v,char w);
int main(){
    AMGraph G1;
    ALGraph G2;
    char v;
    char w;
    CreateUDN(G1);
    //DeleteArc(G1,v,w);
    CreateUDG(G2);
    DeleteArc(G2,v,w);
    return 0;
}
void CreateUDN(AMGraph &G){
    cout<<"-----邻接矩阵创建无向网-----"<<endl;
    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]=MaxInt;
        }
    }
    char v1,v2;
    int w,i,j;
    cout<<"输入一条边的2个顶点和权值："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2>>w;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        G.arcs[i][j]=w;
        G.arcs[j][i]=G.arcs[i][j];
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接矩阵为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        cout<<"[";
        for(int j=0;j<G.vexnum;j++){
            if(G.arcs[i][j]==32767)
                cout<<"* ";
            else
                cout<<G.arcs[i][j]<<" ";
        }
        cout<<"]"<<endl;
    }
}
int LocateVex(AMGraph G,char v){
    for(int i=0;i<G.vexnum;i++){
        if(v==G.vexs[i]){
            return i;
        }
    }
}
void CreateUDG(ALGraph &G){
    cout<<"-----邻接表创建无向网-----"<<endl;
    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].firstarc=NULL;
    }
    char v1,v2;
    int i,j;
    ArcNode *p1,*p2;
    cout<<"输入一条边的2个顶点："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        p1=new ArcNode;
        p1->adjvex=j;
        p1->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p1;
        p2=new ArcNode;
        p2->adjvex=i;
        p2->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p2;
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接表为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i<<"->";
        while(p!=NULL){
            cout<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}
int LocateVex(ALGraph G,char v){
     for(int i=0;i<G.vexnum;i++){
        if(v==G.vertices[i].data){
            return i;
        }
    }
}
void DeleteArc(AMGraph &G,char v,char w){
    cout<<"-----删除一条边-----"<<endl;
    cout<<"此时有"<<G.arcnum<<"条边"<<endl;
    cout<<"输入顶点数据："<<endl;
    cin>>v>>w;
    int i,j,value;
    i=LocateVex(G,v);
    j=LocateVex(G,w);
    G.arcs[i][j]=0;
    G.arcs[j][i]=0;
    G.arcnum--;
    cout<<"删除成功"<<endl;
    cout<<"此时还剩"<<G.arcnum<<"条边"<<endl;
}
void DeleteArc(ALGraph &G,char v,char w){
    cout<<"-----删除一条边-----"<<endl;
    cout<<"此时有"<<G.arcnum<<"条边"<<endl;
    cout<<"输入顶点数据："<<endl;
    cin>>v>>w;
    int i,j,value;
    i=LocateVex(G,v);
    j=LocateVex(G,w);
    ArcNode *p=G.vertices[i].firstarc;
    ArcNode *q;
    q=p;
    while(p && p->adjvex!=j){
        q=p;
        p=p->nextarc;
    }
    if(p && q==p){
        G.vertices[i].firstarc=p->nextarc;
    }else if(p){
        q->nextarc=p->nextarc;
    }
    p=G.vertices[j].firstarc;
    q=p;
    while(p && p->adjvex!=i){
        q=p;
        p=p->nextarc;
    }
    if(p && q==p){
        G.vertices[j].firstarc=p->nextarc;
    }else if(p){
        q->nextarc=p->nextarc;
    }
    G.arcnum--;
    cout<<"删除成功"<<endl;
    cout<<"此时还剩"<<G.arcnum<<"条边"<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i;
        while(p!=NULL){
            cout<<"->"<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}

6-2 一个连通图采用邻接表作为存储结构，设计一个算法，实现从顶点v出发的深度优先遍历的非递归过程。

#include <iostream>
using namespace std;
#define MVNum 100
typedef struct ArcNode{
    int adjvex;
    struct ArcNode * nextarc;
}ArcNode;
typedef struct VNode{
    char data;
    ArcNode *firstarc;
}VNode,AdjList[MVNum];
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;
void CreateUDG(ALGraph &G);
int LocateVex(ALGraph G,char v);
void DFS(ALGraph G,int v);
int main(){
    ALGraph G;
    int v;
    CreateUDG(G);
    cout<<"请输出要从第几个顶点开始深度优先遍历："<<endl;
    cin>>v;
    DFS(G,v);
    return 0;
}
void CreateUDG(ALGraph &G){
    cout<<"-----邻接表创建无向网-----"<<endl;
    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].firstarc=NULL;
    }
    char v1,v2;
    int i,j;
    ArcNode *p1,*p2;
    cout<<"输入一条边的2个顶点："<<endl;
    for(int k=0;k<G.arcnum;k++){
        cin>>v1>>v2;
        i=LocateVex(G,v1);
        j=LocateVex(G,v2);
        p1=new ArcNode;
        p1->adjvex=j;
        p1->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p1;
        p2=new ArcNode;
        p2->adjvex=i;
        p2->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=p2;
    }
    cout<<"创建成功"<<endl;
    cout<<"创建的邻接表为："<<endl;
    for(int i=0;i<G.vexnum;i++){
        ArcNode *p=G.vertices[i].firstarc;
        cout<<i<<"->";
        while(p!=NULL){
            cout<<p->adjvex<<"->";
            p=p->nextarc;
        }
        cout<<endl;
    }
}
int LocateVex(ALGraph G,char v){
     for(int i=0;i<G.vexnum;i++){
        if(v==G.vertices[i].data){
            return i;
        }
    }
}
void DFS(ALGraph G,int v){
    cout<<"-----邻接表存储图的非递归深度优先遍历-----"<<endl;
    //初始化访问标志数组，0为未访问
    int visited[G.vexnum] = {0};
    ArcNode *p,*q;
    visited[v] = 1;
    cout<<v<<" ";
    p = G.vertices[v].firstarc;
    while (p != NULL){
        int temp=p->adjvex;
        while(visited[temp] == 0){
            visited[temp]=1;
            cout<<temp<<" ";
            q=G.vertices[temp].firstarc;
            temp=q->adjvex;
        }
        p=p->nextarc;
    }
}
路漫漫小菜狗
关注
  • 8
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构 C语言版|第2版 严蔚敏》算法设计题答案与书中算法源码版
08-06
采用CLion2020~2021开发，根据CMake文件的描述部署后可直接使用。本人对书中部分算法进行了优化，对参考答案中的所有错误均进行了纠正，对可能产生的bug及其触发条件、算法的不同实现方法或优化思路以及执行过程均进行了详细的说明。赠品为五本经典算法或数据结构书，链接在ReadMe.txt。
图中以邻接矩阵中两种遍历方法以及删减顶点和边的操作（C++）
song_10的博客
12-18 4629
图的广度优先遍历： 从图中某顶点v出发进行广度优先遍历的基本思想是： （1）访问顶点v； （2）依次访问v的各个未被访问的邻接点，v1，v2，v3……，vk； （3）分别从v1，v2，……，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。 广度优先遍历图是以顶点v为起始点，由近至远，依次...
习题1-增加删除顶点和边（邻接矩阵+邻接表）习题2-5 DFS和BFS
weixin_62075168的博客
12-11 3946
本关任务：以邻接矩阵作为存储结构，实现无向图的基本操作。本关任务：以邻接表作为存储结构，实现无向图的基本操作。行后紧接一行为操作的数目。行后紧接一行为操作的数目。输入的第一行为顶点数。个顶点的名称 接下来的。输入的第一行为顶点数。个顶点的名称 接下来的。
数据结构——邻接矩阵
最新发布
2201_75949856的博客
12-05 761
实验内容： 邻接矩阵作为存储结构，实现以下图的基本操作： ①增加新节点 ②删除顶点及相关边 ③增加一条边 ④删除一条边
数据结构(C语言)第二版 第六章课后答案
博客
02-16 3万+
数据结构(C语言)第二版 第六章课后答案 1．选择题 （ 1）在一个图中，所有顶点的度数之和等于图的边数的（）倍。 A． 1/2 B． 1 C． 2 D． 4 答案： C （ 2）在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的（）倍。 A． 1/2 B． 1 C． 2 D． 4 答案： B 解释：有向图所有顶点入度之和等于所有顶点出度之和。 （ 3）具有n 个顶点的有向图最多有（）条边...
数据结构【严蔚敏】C语言第二版图章节课后算法题
Scavenger的博客
10-25 1581
因为邻接矩阵和邻接表的实现原理上无太大差异，所以这里只给出邻接矩阵表示法。输入顶点V0->V3。
【数据结构与算法】分别以邻接矩阵和邻接表作为存储结构实现以下操作：1.增加一个新顶点v、2.删除顶点v及其相关的边、3.增加一条边＜v，w＞、4.删除一条边＜v，w＞
知识虔诚的信徒，探索所有未知是信徒毕生的信仰
07-04 3876
分别以邻接矩阵和邻接表作为存储结构，实现以下操作：1.增加一个新顶点v、2.删除顶点v及其相关的边、3.增加一条边、4.删除一条边
数据结构习题解析与实验指导第六章(图)课后算法设计题
学者的博客
09-02 8093
1.分别以邻接矩阵和邻接表作为存储结构，实现以下图的基本操作： （1）增加一个新顶点vvv, InsertVex(G, v); （2）删除顶点vvv及其相关的边，DeleteVex(G, v); （3）增加一条边<v, w>，InsertArc(G, v, w); （4）删除一条边<v, w>, DeleteArc(G, v, w)。 邻接矩阵(有向图) #include <iostream> using namespace std; struct Graph {
【最详细】数据结构（C语言版 第2版）第六章课后习题答案 严蔚敏 等 编著
热门推荐
weixin_43899069的博客
11-02 5万+
1．选择题 （ 1）在一个图中，所有顶点的度数之和等于图的边数的（）倍。 A． 1/2 B． 1 C． 2 D． 4 答案： C （ 2）在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和的（）倍。 A． 1/2 B． 1 C． 2 D． 4 答案： B 解释：有向图所有顶点入度之和等于所有顶点出度之和。 （ 3）具有 n 个顶点的有向图最多有（）条边。 A． n B ． n(n-1) C． n(n+1) D ． n2 答案： B 解释：有向图的边有方向之分， 即为从 n 个顶点中选取 2 个顶点有序
数据结构第六章关于图的相关作业（一）
min__cheng的博客
11-13 506
为了记录一下我学习数据结构的过程，做一些记录 以邻接矩阵作为存储结构，实现以下图的基本操作： ① 增加⼀个新顶点 v，insert_vex()； ② 删除顶点 v 及其相关的边，delete_vex()； ③ 增加⼀条边，insert_arc()； ④ 删除⼀条边，delete_arc()。
数据结构（C语言版）（第2版）-习题答案（学生版）.pdf
09-02
数据结构C语言习题答案 第2版 严蔚敏
数据结构严蔚敏C语言第二版习题答案（全）
01-05
数据结构严蔚敏C语言第二版习题答案（全）
数据结构（C语言版） 第八章 排序 知识梳理 + 习题详解1
08-03
七、第七章作业答案本系列博客为《数据结构》（C语言版）的学习笔记（上课笔记），仅用于学习交流和自我复习数据结构合集链接： 《数据结构》C语言版（严蔚敏版） 全书
严蔚敏版数据结构课后习题重点算法.docx
12-29
严蔚敏版数据结构课后习题重点算法整理
严蔚敏数据结构c语言版第二版思维导图
路漫漫小菜狗的博客
12-04 5501
数据结构思维导图 参考严蔚敏数据结构c语言版第二版，自己总结的，仅供参考 第一章 绪论 第二章 线性表 第三章 栈和队列 第四章 串、数组和广义表 第五章 树和二叉树 第六章 图 第七章 查找 第八章 排序 ...
第5章课后习题算法设计题（严蔚敏数据结构c语言版第2版）
路漫漫小菜狗的博客
12-05 5355
以二叉链表作为二叉树的存储结构，编写以下算法： （1）统计二叉树的叶节点个数。 （2）判别两棵树是否相等。 （3）交换二叉树每个结点的左孩子和右孩子。 （6）用按层次顺序遍历二叉树的方法，统计树中度为1的结点数目。 5-1 统计二叉树的叶节点个数 #include <iostream> typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; void CreatBiT
单链表的基本操作（c++实现）
路漫漫小菜狗的博客
04-15 4530
（1）编程实现单链表的基本操作：建立单链表，查找单链表，插入单链表，删除单链表； （2）采用单链表结构编程实现：两个有序单链表的归并运算。 /* (1) */ #include <iostream> typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList; bool InitList(...
查找和排序的实现（c++实现）
路漫漫小菜狗的博客
12-05 2457
（1）编程实现两种查找方法：折半查找和二叉排序树。若查找成功，返回元素在有序数组中的位置和查找次数；若查找失败，返回出错标志和查找次数。 （2）在9种排序算法（直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序和基数排序）中选择5种排序算法进行编程实现。 1.折半查找 #include <iostream> using namespace std; int count;//记录查找次数 int Search_Bin(int key[],int low, in
严蔚敏数据结构第二版课后题答案
09-12
但你可以查阅【最详细】数据结构（C语言版 第2版）第八章课后习题答案，该书的作者是严蔚敏等人，该答案可能会对你有所帮助。 此外，你也可以参考转自CSDN博客的文章，其中提供了一些课后题的答案，虽然原文中没有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值