《数据结构》实验三报告（无向图邻接表的构造）

最新推荐文章于 2023-07-30 06:45:00 发布
最新推荐文章于 2023-07-30 06:45:00 发布
阅读量1.8k 收藏 4
点赞数
分类专栏： 课程实验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zstuyyyyccccbbbb/article/details/111937344
版权 
#include<iostream>
#include<vector>
#include<queue>
#include<cstring>
#include<cmath>
#include<map>
#include<set>
#include<cstdio>
#include<algorithm>
#define debug(a) cout<<#a<<"="<<a<<endl;
using namespace std;
const int maxn=1e3;
typedef int LL;
typedef struct LNode* ToNode;
typedef struct Graph* ToGraph;
typedef struct LNode{///单链表
    LL num;///顶点编号
    LL val;///表头节点到直连点的边权
    LL indegree;///表头节点存下该点的入度
    LL outdegree;///表头节点存下该点的出度
    ToNode Next;
}LNode;
typedef struct Graph{
    ToNode A[maxn];
    LL graphnodes;///图的顶点数
    LL graphedges;///图的边数
}Graph;
void addnode(ToGraph &G,LL v1,LL v2){
    ToNode p=(ToNode)malloc(sizeof(LNode));
    p=(G->A[v1]);
    while( p->Next!=nullptr ){
        p=p->Next;
        if(p->num==v2) return;
        if(p==nullptr) break;
    }
    ToNode k=(ToNode)malloc(sizeof(LNode));
    p->Next=k;
    k->num=v2;
    k->Next=nullptr;
    return;
}
void find(ToGraph &G,LL v1,LL v2){
        if(G->A[v1]->num==v1){
            addnode(G,v1,v2);
            cout<<"找到"<<v1<<"顶点"<<endl;
            G->A[v1]->outdegree++;///该点出度++
        }
        if(G->A[v2]->num==v2){

            G->A[v2]->indegree++;///该点入读++
            cout<<(G->A[v2]->indegree)<<endl;
        }
}
void CreateGraph(ToGraph& G,LL op){
    G=(ToGraph)malloc(sizeof(Graph));
    if(op==0) cout<<"要构建的无向图的顶点数目:"<<endl;
    else if(op==1) cout<<"要构建的有向图的点数目:"<<endl;
    cin>>(G->graphnodes);
    if(op==0) cout<<"要构建的无向图的边的数目:"<<endl;
    else if(op==1) cout<<"要构建的有向图的边数目:"<<endl;
    cin>>(G->graphedges);
    for(LL i=1;i<=(G->graphnodes);i++){
        LL v;
        cout<<"顶点为:";cin>>v;
        G->A[v]=(ToNode)malloc(sizeof(LNode));
        G->A[v]->num=v;
        G->A[v]->indegree=0;
        G->A[v]->outdegree=0;
        G->A[v]->Next=nullptr;
    }
    for(LL i=1;i<=(G->graphedges);i++){
        cout<<"请输入边(vi,vj)上的顶点信息"<<endl;
        LL v1,v2;///v1<---->v2
        cin>>v1>>v2;
        if(op==0){
            find(G,v1,v2);
            find(G,v2,v1);
        }
        else if(op==1){
            find(G,v1,v2);
        }
    }
}
LL findnum(ToGraph& G,LL v){
    for(LL i=1;i<=G->graphnodes;i++){
        if(G->A[i]->num==v) return i;
    }
    return 0;
}
void showGraph(ToGraph& G){
    cout<<"所建立的邻接表如下:"<<endl;
    for(LL i=1;i<=G->graphnodes;i++){
        ///LL v=findnum(G,i);///找标号为i的点
        cout<<"标号为"<<i<<"的点:";
        ToNode p=G->A[i];
        if(p->Next==nullptr){
            cout<<"该点没有相连点";
        }
        else{
            while(p->Next!=nullptr){
                p=p->Next;
                cout<<" "<<p->num<<" ";
            }
        }
        cout<<endl;
    }
}
bool checkedge(ToGraph& G){
    LL v1,v2;
    cout<<"输入边的端点v1:";cin>>v1;
    cout<<"输入边的端点v2:";cin>>v2;
    ToNode p=G->A[v1];
    if(p->Next==nullptr) return 0;
    while(p->Next!=nullptr){
        p=p->Next;
        if(p->num==v2) return 1;
    }
    return 0;
}
void caldegree(ToGraph& G,LL op){///计算入度和出度
     if(op==1){
        for(LL i=1;i<=G->graphnodes;i++){
            cout<<"起点为"<<i<<":";
            cout<<"该点"<<i<<"的入度为:"<<G->A[i]->indegree<<endl;
            cout<<"该点"<<i<<"的出度为:"<<G->A[i]->outdegree<<endl;
            cout<<endl;
        }
     }
     else{
         for(LL i=1;i<=G->graphnodes;i++){
            cout<<"起点为"<<i<<":";
            cout<<"该点"<<i<<"的度数为:"<<G->A[i]->indegree<<endl;
            cout<<endl;
        }
     }
}
int main(void)
{
  ///cin.tie(0);std::ios::sync_with_stdio(false);
  ToGraph G;
  cout<<"选择构建无向图(输入0)or有向图(输入1)"<<endl;
  LL op;cin>>op;
  if(op==0){
    CreateGraph(G,0);///无向图
  }
  else if(op==1){
    CreateGraph(G,1);///有向图
  }
  showGraph(G);
  cout<<"判断边是否存在"<<endl;
  if(checkedge(G)){
    cout<<"该边存在"<<endl;
  }
  else cout<<"该边不存在"<<endl;
  caldegree(G,op);
return 0;
}

如果不是连续的就按照输入顺序输出单链表

#include<iostream>
#include<vector>
#include<queue>
#include<cstring>
#include<cmath>
#include<map>
#include<set>
#include<cstdio>
#include<algorithm>
#define debug(a) cout<<#a<<"="<<a<<endl;
using namespace std;
const int maxn=1e3;
typedef int LL;
typedef struct LNode* ToNode;
typedef struct Graph* ToGraph;
typedef struct LNode{///单链表
    LL num;///顶点编号
    LL val;///表头节点到直连点的边权
    LL indegree;///表头节点存下该点的入度
    LL outdegree;///表头节点存下该点的出度
    ToNode Next;
}LNode;
typedef struct Graph{
    ToNode A[maxn];
    LL graphnodes;///图的顶点数
    LL graphedges;///图的边数
}Graph;
void addnode(ToGraph &G,LL _v1,LL _v2){
    ToNode p=(ToNode)malloc(sizeof(LNode));
    p=(G->A[_v1]);
    while( p->Next!=nullptr ){
        p=p->Next;
        if(p->num==G->A[_v2]->num) return;///重边只有一次顶点
        if(p==nullptr) break;
    }
    ToNode k=(ToNode)malloc(sizeof(LNode));
    p->Next=k;
    k->num=G->A[_v2]->num;
    k->Next=nullptr;
    return;
}
LL findnum(ToGraph& G,LL v){
    for(LL i=1;i<=G->graphnodes;i++){
        if(G->A[i]->num==v) return i;
    }
    return 0;
}
void find(ToGraph &G,LL v1,LL v2){
        LL _v1=findnum(G,v1);
        LL _v2=findnum(G,v2);
      ///  debug(_v1);debug(_v2);
        if(G->A[_v1]->num==v1){
            addnode(G,_v1,_v2);
            cout<<"找到"<<v1<<"顶点"<<endl;
            G->A[_v1]->outdegree++;///该点出度++
        }
        if(G->A[_v2]->num==v2){
            G->A[_v2]->indegree++;///该点入读++
        }
}
void CreateGraph(ToGraph& G,LL op){
    G=(ToGraph)malloc(sizeof(Graph));
    if(op==0) cout<<"要构建的无向图的顶点数目:"<<endl;
    else if(op==1) cout<<"要构建的有向图的点数目:"<<endl;
    cin>>(G->graphnodes);
    if(op==0) cout<<"要构建的无向图的边的数目:"<<endl;
    else if(op==1) cout<<"要构建的有向图的边数目:"<<endl;
    cin>>(G->graphedges);
    for(LL i=1;i<=(G->graphnodes);i++){
        LL v;
        cout<<"顶点为:";cin>>v;
        G->A[i]=(ToNode)malloc(sizeof(LNode));
        G->A[i]->num=v;
        G->A[i]->indegree=0;
        G->A[i]->outdegree=0;
        G->A[i]->Next=nullptr;
    }
    for(LL i=1;i<=(G->graphedges);i++){
        cout<<"请输入边(vi,vj)上的顶点信息"<<endl;
        LL v1,v2;///v1<---->v2
        cin>>v1>>v2;
        if(op==0){
            find(G,v1,v2);
            find(G,v2,v1);
        }
        else if(op==1){
            find(G,v1,v2);
        }
    }
    cout<<"构造完成"<<endl;
}
void showGraph(ToGraph& G){
    cout<<"按输入顺序所建立的邻接表如下:"<<endl;
    for(LL i=1;i<=G->graphnodes;i++){///按顺序输出单链表
        ///LL v=findnum(G,i);///找标号为i的点
        cout<<"标号为"<<G->A[i]->num<<"的点:";
        ToNode p=G->A[i];
        if(p->Next==nullptr){
            cout<<"该点没有相连点";
        }
        else{
            while(p->Next!=nullptr){
                p=p->Next;
                cout<<" "<<p->num<<" ";
            }
        }
        cout<<endl;
    }
}
bool checkedge(ToGraph& G){
    LL v1,v2;
    cout<<"输入边的端点v1:";cin>>v1;
    cout<<"输入边的端点v2:";cin>>v2;
    LL _v1=findnum(G,v1);
    ToNode p=G->A[_v1];
    if(p->Next==nullptr) return 0;
    while(p->Next!=nullptr){
        p=p->Next;
        if(p->num==v2) return 1;
    }
    return 0;
}
void caldegree(ToGraph& G,LL op){///计算入度和出度
     if(op==1){
        for(LL i=1;i<=G->graphnodes;i++){
            cout<<"当前点为"<<G->A[i]->num<<":";
            cout<<"该点"<<G->A[i]->num<<"的入度为:"<<G->A[i]->indegree<<endl;
            cout<<"该点"<<G->A[i]->num<<"的出度为:"<<G->A[i]->outdegree<<endl;
            cout<<endl;
        }
     }
     else{
         for(LL i=1;i<=G->graphnodes;i++){
            cout<<"当前点为"<<G->A[i]->num<<":";
            cout<<"该点"<<G->A[i]->num<<"的度数为:"<<G->A[i]->indegree<<endl;
            cout<<endl;
        }
     }
}
int main(void)
{
  ///cin.tie(0);std::ios::sync_with_stdio(false);
  ToGraph G;
  cout<<"选择构建无向图(输入0)or有向图(输入1)"<<endl;
  LL op;cin>>op;
  if(op==0){
    CreateGraph(G,0);///无向图
  }
  else if(op==1){
    CreateGraph(G,1);///有向图
  }
  cout<<"fuck"<<endl;
  showGraph(G);
  cout<<"判断边是否存在"<<endl;
  if(checkedge(G)){
    cout<<"该边存在"<<endl;
  }
  else cout<<"该边不存在"<<endl;
  caldegree(G,op);
return 0;
}

 

小菜鸡加油
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
头歌数据结构图的邻接表存储及遍历操作
05-26
头歌数据结构图的邻接表存储及遍历操作 第1关图的邻接表存储及求邻接点操作 第2关图的深度遍历 第3关图的广度遍历 稳过
dfs, bfs之邻接表无向图实验
李典金
12-02 894
dfs, bfs之邻接表无向图实验
数据结构/数据结构与算法实验三 图的相关算法实现
zombotany的博客
01-29 1616
1.实验题目 1.【功能1】建立一个无向图。 2.【功能2】按深度优先遍历该无向图，输出遍历序列。 3.【功能3】按广度优先遍历该无向图，输出遍历序列。 2.实验要求 1、无向图以邻接矩阵或邻接表作为存储结构 2、主程序测试数据 3.算法思路 1.类的设计 这次实验可以设计出一个邻接表作为图的存储结构。因为题目要求图的边没有权值，所以，我们可以对课本上的邻接表作一些适当简化。在设计图的边类adjlistnetworkarc类时，可以去掉边权域，仅保留顶点域和指针域。在设计图类adjlistdirnetwo
《数据结构与算法》实验报告——无向图邻接表的构造
无限迭代中......
12-09 5265
《数据结构》实验报告 学号： 2018329621200 机器号 10-414-28 姓名： 申屠志刚 日期： 2019/12/9 程序名： main.cpp ...
数据结构实验报告（三）——图的操作和实现
半岛铁盒里
01-14 6230
数据结构实验——图的操作
实验三 无向图以及有向图的邻接表
123的博客
12-30 3147
一、目的和要求（需求分析）： 1、掌握邻接表的存储结构以及邻接表的建立和操作。 2、 构造一个无向图的邻接表，要求从键盘输入图的顶点数和图的边数，并显示所构造的邻接表） 基本要求：1. 构造一个无向图的邻接表 2. 屏幕输出 实验拓展：1. 构建有向图的邻接表 2. 判断边是否存在 3. 求顶点的度数 二、程序设计的基本思想，原理和算法描述： 根据实验要求，基于下图例子： 首先定义邻接表的结构，随后根据输入的图的顶点数和图的边数，分别构造出有向图和无向图的邻接表。邻接表结构具体如下所示： typedef s
C++数据结构实验四：图的应用
01-16
5. 掌握图的逻辑结构特点、无向图和有向图的两种存储结构表示 6. 掌握图的深度优先和广度优先算法思想，最小生成树的概念以及普利姆算法和克鲁斯卡尔构造最小生成树的过程。 实验内容 假设有一张城市地图，图中的...
数据结构实验-构造图的最小生成树
10-26
输入格式（无向图的邻接矩阵）： 8 10, 0 5, 6, 0 0, 3, 13, 0 二、实验目的 掌握图的存储方法、Prim算法或Kruskal算法。 三、实验内容及要求 1、构造图的存储结构。 2、实现Prim算法或Kruskal算法，求出给定无向图...
数据结构实验报告-图的遍历.doc
07-11
数 据 结 构实 验 报 告 实验：图的遍历 一、实验目的： 1、理解并掌握图的逻辑结构和物理结构——邻接矩阵、邻接表 2、掌握图的构造方法 3、掌握图的邻接矩阵、邻接表存储方式下基本操作的实现算法 4、掌握图的深度...
数据结构实验报告。doc
05-10
要求：以邻接矩阵或邻接表为存储结构，以用户指定的顶点为起始点，实现连通无向图的深度优先及广度优先搜索遍历，并输出遍历的结点序列。（注：学号为单号的学生使用邻接矩阵存储结构实现，学号为双号的学生使用邻接...
无向图（数据结构）
08-12
本程序实现无向图的一些基本操作，适于初学者参考。
实验三：无向图邻接表的构造
qq_51737737的博客
06-02 311
基本要求：1. 构造一个无向图的邻接表 屏幕输出 实验拓展：1. 构建有向图的邻接表 2. 判断边是否存在 3. 求顶点的度数 #include<bits/stdc++.h> using namespace std; const int maxn=1e6; int n,m; struct bnode { int num; char data; struct bnode *next; }; struct tnode { char data; bnode *firsno
实验10、构造无向图（算法7.1），深度和广度遍历 （简单易懂，注释超级全，代码可以直接运行）
于笨笨的博客
09-24 1269
实验10、构造无向图（算法7.1），深度和广度遍历 （简单易懂，注释超级全，代码可以直接运行） 恭喜你，这是数据结构的最后一个实验啦，实验序号可能不对，但是饰演的数量和顺序是一个不错der （1）实验目的 通过该实验，使学生掌握图的几种存储结构，理解图的深度优先和广度优先遍历算法的思想和实现办法， （2）实验内容 实现教材算法7.2利用邻接矩阵构造无向图的算法，提供从邻接矩阵获得邻接表的功能，在此基础上进行深度优先遍历和广度优先遍历。 （3）参考界面 （4）验收/测试用例  创建所示无向图 屏幕输出邻接
06-图1 列出连通集 (25分)
chstor's blog
04-25 235
06-图1 列出连通集 (25分) 给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。 输入格式: 输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。 每行输出一个连通集。先输出D...
【数据结构实验四】- 图的存储和遍历 - （无向图、有向图，深度优先、广度优先遍历）
m0_46233342的博客
03-04 7659
文章目录一、实验题目：二、实验目的：三、实验内容：1.建立无向图的邻接矩阵存储结构，进行深度优先遍历和广度优先遍历。程序代码：2.建立有向图的邻接表存储结构，进行深度优先遍历和广度优先遍历。程序代码：四、实验心得体会 实验四 一、实验题目： 图的存储和遍历 二、实验目的： ⑴ 掌握图的逻辑结构； ⑵ 掌握图的邻接矩阵存储结构和图的邻接表存储结构； ⑶ 验证图的邻接矩阵存储和邻接表的存储以及深度优先遍历和广度优先遍历操作的实现。 三、实验内容： （1）建立无向图的邻接矩阵存储； （2）对建立的无向图，进行深
数据结构实验-无向图-通信网络的建立
persistenthuang
10-30 2967
内容： 项目名称：通信网构建 项目内容： 在 n 个城市之间建立通信联络网，则连通 n 个城市只需要 n-1 条线路。 要求在 最节省经费的前提下建立这个通信网。 （1） 完成城市信息的输入。 （2） 完成城市信息的编辑，包括城市以及城市间距离的增加，删除，信息修改等。 （3） 允许用户指定下列两种策略进行通信网的构建 1.采用 Prim 算法进行通信网的构建； 2.采用 Kruskal 算法进行...
C数据结构——无向图(邻接表方式) 创建与基本使用
最新发布
小象的个人博客
07-30 1105
【代码】C数据结构——无向图(邻接表方式) 创建与基本使用。
邻接矩阵（图）基本操作：建立无向图、有向图 代码实现（C语言）
知且行的博客
02-03 6383
邻接矩阵存储结构： 创建无向图、有向图： #include<stdio.h> #include<stdlib.h> #define MaxVexNum 100 #define MaxInt 32767 //邻接矩阵 typedef int VertexType; typedef int EdgeType; typedef struct AMGraph{ Verte...
Python实验二
热门推荐
qq_54226199的博客
04-19 1万+
程序片段编程题 1. 题库：把数列的元素重复n次，然后元素的平方形成新列表，然后去除重复元素 【问题描述】 读入一个整数列表和正整数n(n>1)，把列表中每个元素重复n次，并对每个元素进行平方形成新的列表，最后去除列表中的重复元素。打印输出新列表。 【输入形式】 第一行输入列表，包括方括号，元素之间用逗号分隔。 第二行输入重复的次数。 【输出形式】 直接用print输出列表 【样例输入】 [2,3,4,5,5] 5 【样例输出】 [4, 9, 16, 25] ls = eval(input()) n
邻接表创建无向图
05-24
邻接表是一种常见的图的存储方式，可以用于存储有向图和无向图。下面是邻接表创建无向图的步骤： 1. 定义一个邻接表的数据结构，一般包含两个部分：节点数组和邻接表数组。 2. 定义节点结构体，包含节点的值和指向第一个邻接节点的指针。 3. 初始化邻接表数组，将每个元素的指针初始化为 NULL。 4. 读取无向图的边信息，对于每条边 (u, v)，在节点 u 和节点 v 的邻接表中分别添加一个指向对方节点的指针。 5. 如果无向图中存在自环边，即 (u, u)，则在节点 u 的邻接表中只添加一个指向自己的指针。 6. 最后输出邻接表即可。 下面是用 C++ 代码实现的邻接表创建无向图的过程： ```c++ #include <iostream> #include <vector> using namespace std; // 节点结构体 struct Node { int val; // 节点的值 Node* next; // 指向下一个邻接节点的指针 }; // 邻接表数据结构 class AdjacencyList { public: // 构造函数 AdjacencyList(int n) { nodes.resize(n); for (int i = 0; i < n; i++) { nodes[i].val = i; // 节点值初始化为下标 nodes[i].next = NULL; } } // 添加无向图边 void addEdge(int u, int v) { Node* node_u = &nodes[u]; while (node_u->next != NULL) { node_u = node_u->next; } Node* new_node_u = new Node(); new_node_u->val = v; new_node_u->next = NULL; node_u->next = new_node_u; Node* node_v = &nodes[v]; while (node_v->next != NULL) { node_v = node_v->next; } Node* new_node_v = new Node(); new_node_v->val = u; new_node_v->next = NULL; node_v->next = new_node_v; } // 输出邻接表 void printList() { for (int i = 0; i < nodes.size(); i++) { Node* node = &nodes[i]; cout << node->val << " -> "; while (node->next != NULL) { node = node->next; cout << node->val << " -> "; } cout << "NULL" << endl; } } private: vector<Node> nodes; // 节点数组 }; int main() { int n, m; // n 个节点，m 条边 cin >> n >> m; AdjacencyList list(n); // 创建邻接表 for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; list.addEdge(u, v); // 添加无向图边 } list.printList(); // 输出邻接表 return 0; } ``` 上述代码中，我们首先定义了一个节点结构体 `Node`，包括节点的值和指向下一个邻接节点的指针。然后定义了一个邻接表数据结构 `AdjacencyList`，包括节点数组和邻接表数组，其中节点数组中每个元素表示一个节点，邻接表数组中每个元素表示一个节点的邻接表。在 `AdjacencyList` 类中，我们实现了添加无向图边和输出邻接表的方法。在 `main` 函数中，我们读取节点数和边数，然后创建邻接表并添加边，最后输出邻接表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值