BUCT数据结构——图

最新推荐文章于 2024-07-19 19:11:19 发布
最新推荐文章于 2024-07-19 19:11:19 发布
阅读量648 收藏 5
点赞数 2
分类专栏： 应试数据结构 文章标签： 算法 c语言 c++ 北京化工大学 buct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41729237/article/details/121592966
版权

文章目录

问题 A: 将邻接矩阵存储的图转换为邻接表存储的图

#include<bits/stdc++.h>
using namespace std;

#define MAX_SIZE 100

// 邻接矩阵存储的图
struct Graph{
    int vexNumber;
    string info[MAX_SIZE];
    int adjMatrix[MAX_SIZE][MAX_SIZE];
    Graph(){
        vexNumber=0;
        memset(adjMatrix,0,sizeof(adjMatrix));
    }
};

// 弧结点定义
struct ArcNode
{
    int weight; // 弧上的信息部分
    int adj;        // 邻接点的序号
    ArcNode *nextarc;
    ArcNode(){
        nextarc=NULL;
    }
};


// 顶点结点定义，也就是头节点定义 
struct VexNode
{
    string Info;        // 顶点上的信息部分
    ArcNode *firstarc;  // 弧链头指针
    VexNode(){
        firstarc=NULL;
        Info.clear();
    }
};

// 邻接表结构的图的定义
struct linkGraph
{
    VexNode *vexes;
    int vexnumber;
    linkGraph(){
        vexes=NULL;
    }
};

int InitGraph(linkGraph &G, int vexnumber)
{
    G.vexes = new VexNode[vexnumber];
    G.vexnumber = vexnumber;
    for (int i = 0; i < vexnumber; i++)
        G.vexes[i].firstarc = NULL;
    return 0;
}

// 将邻接矩阵存储的图转换为邻接表存储的图
void InitGraph(linkGraph &G, const Graph& g){
    int n=g.vexNumber;
    InitGraph(G,g.vexNumber);
    // cout<<G.vexnumber<<endl;
    for( int i=0;i<n;i++){
        G.vexes[i].Info=(char)(i+'a');
        for( int j=0;j<n;j++){
            if(g.adjMatrix[i][j]){
                ArcNode * NewNode=new ArcNode;
                NewNode->nextarc= G.vexes[i].firstarc;
                G.vexes[i].firstarc=NewNode;
                NewNode->weight=j;
            }
        }
    }
}

int DestroyGraph(linkGraph &G)
{
    for (int i = 0; i < G.vexnumber; i++)
    {
        while (G.vexes[i].firstarc != NULL)
        {
            ArcNode *p = G.vexes[i].firstarc;
            G.vexes[i].firstarc = p->nextarc;
            delete p;
        }
    }
    delete[]G.vexes;
    G.vexes = NULL;
    G.vexnumber = 0;
    return 0;
}


// 输出邻接表存储的图
void PrintGraph(const linkGraph& G){
    int n=G.vexnumber;
    for( int i=0;i<n;i++){
        cout<<G.vexes[i].Info;
        ArcNode *p=G.vexes[i].firstarc;
        while(p!=NULL){
            printf(" --> %c",p->weight+'a');
            p=p->nextarc;
        }
        cout<<endl;
    }
    return ;
}
// please comment the following code when you submit to OJ
int main(){
    //freopen("/config/workspace/answer/test.in","r",stdin);
    //freopen("/config/workspace/answer/test.out","w",stdout);
    Graph g;
    cin >> g.vexNumber;
    for(int i=0;i<g.vexNumber;i++){
        g.info[i] = (char)('a'+i);
        for(int j=0;j<g.vexNumber;j++){
            cin >> g.adjMatrix[i][j];
        }
    }
    linkGraph G;
    InitGraph(G,g);
    PrintGraph(G);
    DestroyGraph(G);
    return 0;
}

问题 B: 邻接表存储的图转化为邻接矩阵存储的图

#include<bits/stdc++.h>
using namespace std;

#define MAX_SIZE 100

// 邻接矩阵存储的图
struct Graph
{
    int vexNumber;
    string vexInfo[MAX_SIZE];
    int adjMatrix[MAX_SIZE][MAX_SIZE];
};

// 弧结点定义
struct ArcNode
{
    int weight;       // 弧上的信息部分
    int adj;          // 邻接点的序号
    ArcNode *nextarc; // 下一条边
    ArcNode(){
        nextarc =NULL;
    }
};

// 顶点结点定义
struct VexNode
{
    string Info;       // 顶点上的信息部分
    ArcNode *firstarc; // 弧链头指针
    VexNode(){
        firstarc=NULL;
    }
};

// 邻接表结构的图的定义
struct linkGraph
{
    VexNode *vexes; //  每个节点的邻接表
    int vexnumber;  //  节点数量
};

// 邻接表存储的图的初始化
int InitGraph(linkGraph &G, int vexnumber)
{
    G.vexes = new VexNode[vexnumber];
    G.vexnumber = vexnumber;
    for (int i = 0; i < vexnumber; i++)
        G.vexes[i].firstarc = NULL;
    return 0;
}

// 构造边节点指针
// ArcNode* getArcNode(int adj){
//     ArcNode* node = new ArcNode();
//     node->adj = adj;
//     node->nextarc = NULL;
//     return node;
// }

// 根据输入构造邻接表存储的图
void InputlinkGraph(linkGraph& LG){
    int n;
    cin>>n;
    InitGraph(LG,n);
    for( int i=0;i<n;i++){
        string s;
        cin>>s;
        int head=s[0]-'a';
        LG.vexes[head].Info=s[0];
        for( int j=s.size()-1;j>=2;j-=2){
            ArcNode * NewNode=new ArcNode;
            NewNode->weight=s[j]-'a';
            NewNode->nextarc=LG.vexes[head].firstarc;
            LG.vexes[head].firstarc=NewNode;
        }
    }
    return ;
}
// 将邻接表存储的图转化为邻接矩阵存储的图
void linkGraph2Graph(const linkGraph& LG, Graph& G){
    memset(G.adjMatrix,0,sizeof G.adjMatrix);
    int n=LG.vexnumber;
    G.vexNumber=n;
    for( int i=0;i<n;i++){
        ArcNode * p=LG.vexes[i].firstarc;
        while(p!=NULL){
            int j=p->weight;
            G.adjMatrix[i][j]=1;
            p=p->nextarc;
        }
    }
    return ;
}

// 输出邻接矩阵
void printGraph(const Graph& G){
    int n=G.vexNumber;
   for( int i=0;i<n;i++){
       for( int j=0;j<n;j++){
           cout<<G.adjMatrix[i][j]<<" ";
       }
       cout<<endl;
   }
}

void PrintlinkGraph(const linkGraph &LG){
    int n=LG.vexnumber;
    for( int i=0;i<n;i++){
        cout<<LG.vexes[i].Info;
        ArcNode *p=LG.vexes[i].firstarc;
        while(p!=NULL){
            printf(" --> %c",p->weight+'a');
            p=p->nextarc;
        }
        cout<<endl;
    }
}

// 邻接表存储的图的销毁
int DestroylinkGraph(linkGraph &G)
{
    for (int i = 0; i < G.vexnumber; i++)
    {
        while (G.vexes[i].firstarc != NULL)
        {
            ArcNode *p = G.vexes[i].firstarc;
            G.vexes[i].firstarc = p->nextarc;
            delete p;
        }
    }
    delete[] G.vexes;
    G.vexes = NULL;
    G.vexnumber = 0;
    return 0;
}
// please comment the following code when you submit to OJ
int main(){
    // freopen("/config/workspace/answer/test.in","r",stdin);
    linkGraph LG;
    Graph G;
    InputlinkGraph(LG);
    PrintlinkGraph(LG);
    linkGraph2Graph(LG,G);
    printGraph(G);
    DestroylinkGraph(LG);
    return 0;
}

问题 C: 邻接矩阵存储图的DFS

#include<bits/stdc++.h>
using namespace std;

#define MAX_SIZE 100

// 邻接矩阵存储的图
struct Graph
{
    int vexNumber;
    string vexInfo[MAX_SIZE];
    int adjMatrix[MAX_SIZE][MAX_SIZE];
};

// 查找v0的未被访问的邻接点
// int findAdjVex(const Graph& G, int v0, int visited[]){

// }
// 以顶点v0为起点，进行一趟DFS
void DFS(const Graph& G, int v0, int visited[]){
    // 第一步： 先访问v0，标记已访问
    visited[v0]=1;
    cout<<v0<<" ";
    // 第二步： 再对v0的所有未被访问的邻接点进行DFS
    for( int i=0;i<G.vexNumber;i++){
        if(G.adjMatrix[v0][i]==1&&visited[i]==0){
            DFS(G,i,visited);
        }
    }
}
// 对整个图进行DFS
void DFS(const Graph& G){
    // 第一步：初始化visited数组
    int visited[MAX_SIZE]={};
    // 第二步：以每个未被遍历的顶点为起点，进行DFS
    for( int i=0;i<G.vexNumber;i++){
        if(visited[i]==0) DFS(G,i,visited);
    }
    
}

// please comment the following code when you submit to OJ
int main(){
    // freopen("/config/workspace/answer/test.in","r",stdin);
    // freopen("/config/workspace/answer/test.out","w",stdout);
    
    Graph G;
    cin >> G.vexNumber;
    for(int i=0;i<G.vexNumber;i++){
        //我的编译器to_string没法用
        G.vexInfo[i] = (char)(i+'a');
        for(int j=0;j<G.vexNumber;j++){
            cin >> G.adjMatrix[i][j];
        }
    }
    DFS(G);
    return 0;
}

问题 D: 邻接矩阵存储图的DFS-非递归算法

#include <iostream>
#include <string>
#include <cstdio>
#include <stack>
#include <queue>
using namespace std;

#define MAX_SIZE 100

// 邻接矩阵存储的图
struct Graph
{
    int vexNumber;
    string vexInfo[MAX_SIZE];
    int adjMatrix[MAX_SIZE][MAX_SIZE];
};

// 查找v0的未被访问的邻接点
int findAdjVex(const Graph& G, int v0, int visited[]){
    for( int i=0;i<G.vexNumber;i++){
        if(G.adjMatrix[v0][i]==1&&visited[i]==0) return i; 
    }
    return -1;
}
// 以顶点v0为起点，进行一趟DFS
string DFS(const Graph& G, int v0, int visited[]){
    string result = "";
    stack<int>st;
    st.push(v0);
    result+=to_string(v0);
    result+=" ";
    visited[v0]=1;
    while(!st.empty()){
        int now=st.top();
        int to=findAdjVex(G,now,visited);
        if(to==-1) {
            st.pop();
            continue;
        }
        else {
            st.push(to);
            visited[to]=1;
            result+=to_string(to);
            result+=" ";
        }
    }
    return result;
}
// 对整个图进行DFS
string DFS(const Graph& G){
    string result = "";
    // 第一步：初始化visited数组
    const int n=G.vexNumber;
    int visited[MAX_SIZE]={};
    // 第二步：以每个未被遍历的顶点为起点，进行DFS
    for( int i=0;i<n;i++){
        if(visited[i]==0) result+= DFS(G,i,visited);
    }
    return result;
}

// please comment the following code when you submit to OJ
int main(){
    // freopen("/config/workspace/answer/test.in","r",stdin);
    // freopen("/config/workspace/answer/test.out","w",stdout);
    
    Graph G;
    cin >> G.vexNumber;
    for(int i=0;i<G.vexNumber;i++){
        G.vexInfo[i] = (char)(i+'a');
        for(int j=0;j<G.vexNumber;j++){
            cin >> G.adjMatrix[i][j];
        }
    }
    string str = DFS(G);
    cout << str << endl;
    return 0;
}

问题 E: 邻接矩阵存储图的BFS

#include<bits/stdc++.h>
using namespace std;
int m[110][110];
void bfs(int n){
    int vis[110]={};
    queue<int>q;
    for( int i=1;i<=n;i++){
        if(!vis[i]) q.push(i);
        else continue;
        while(!q.empty()){
            int now=q.front();
            q.pop();
            if(vis[now]) continue;
            vis[now]=1;
            cout<<now-1<<" ";
            for( int j=1;j<=n;j++){
                if(!vis[j]&&m[now][j]){
                    q.push(j);
                }
            }
        }
    }
}
int main(){
    int n;
    cin>>n;
    for( int i=1;i<=n;i++){
        for( int j=1;j<=n;j++){
            cin>>m[i][j];
        }
    }
    bfs(n);
}

问题 F: 案例6-1.2：邻接表存储图的广度优先遍历

#include<bits/stdc++.h>
using namespace std;
vector<int>h[100100];
int vis[100100];
void bfs( int x){
    queue<int>q;
    q.push(x);
    while(!q.empty()){
        int now=q.front();
        q.pop();
        if(vis[now]==1) continue;
        vis[now]=1;
        cout<<now<<" ";
        for( int i=0;i<h[now].size();i++){
            int to=h[now][i];
            if(vis[to]) continue;
            else q.push(to);
        }
    }
}
int main(){
    int n,m,x;
    cin>>n>>m>>x;
    for( int i=1;i<=m;i++){
        int a,b;
        cin>>a>>b;
        h[a].push_back(b);
        h[b].push_back(a);
    }
    for( int i=0;i<n;i++) sort(h[i].begin(),h[i].end());
    bfs(x);
}

问题 G: 邻接矩阵存储图的DFS完成序求解

#include <iostream>
#include <string>
#include <cstdio>
#include <stack>
#include <queue>
using namespace std;

#define MAX_SIZE 100

// 邻接矩阵存储的图
struct Graph
{
    int vexNumber;
    string vexInfo[MAX_SIZE];
    int adjMatrix[MAX_SIZE][MAX_SIZE];
};

// 查找v0的未被访问的邻接点
int findAdjVex(const Graph& G, int v0, int visited[]){
    for( int i=0;i<G.vexNumber;i++){
        if(G.adjMatrix[v0][i]==1&&visited[i]==0) return i; 
    }
    return -1;
}

// 算法7-1： 以某个节点为起点求解DFS完成序的算法 （邻接矩阵）
string DFS_finished(const Graph &G, int v0, int visited[]){
    string res="";
    visited[v0]=1;
    while(findAdjVex(G,v0,visited)!=-1){
        res+=DFS_finished(G,findAdjVex(G,v0,visited),visited);
    }
    res+=(char)(v0+'a');  
    return res;
}

// 算法7: DFS完成序的求解算法-邻接矩阵
string DFS_finished(const Graph &G){
    string res="";
    int n=G.vexNumber;
    int visited[MAX_SIZE]={};
    for( int i=0;i<n;i++){
        if(visited[i]==0) res+=DFS_finished(G,i,visited);
    }
    return res;
}
// please comment the following code when you submit to OJ
int main(){
    // freopen("/config/workspace/answer/test.in","r",stdin);
    // freopen("/config/workspace/answer/test.out","w",stdout);
    
    Graph G;
    cin >> G.vexNumber;
    for(int i=0;i<G.vexNumber;i++){
        G.vexInfo[i] = (char)('a'+ i);
        for(int j=0;j<G.vexNumber;j++){
            cin >> G.adjMatrix[i][j];
        }
    }
    string str = DFS_finished(G);
    cout << str << endl;
    return 0;
}

问题 H: 算法7-7,7-8：无向图的连通分量和生成树

#include<bits/stdc++.h>
using namespace std;
int m[100][100];
int vis[100];
int n;
string dfs( int x){
    string res="";
    res+=to_string(x);
    res+=" ";
    vis[x]=1;
    for( int i=0;i<n;i++){
        if(vis[i]==0&&m[x][i]==1){
            res+=dfs(i);
        }
    }
    return res;
}
int main(){
    cin>>n;
    for( int i=0;i<n;i++){
        for( int j=0;j<n;j++){
            cin>>m[i][j];
        }
    }
    for( int i=0;i<n;i++){
        if(vis[i]==0){
            cout<<dfs(i)<<endl;
        }
    }
}
_zpf
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BUCTOJ题目部分源码（仅供学习和参考）
12-30
BUCTOJ部分试题的源码，包括有大概200多道题目，仅供学习和参考，当然其他OJ系统也会有类似的题目，也可以进行学习可参考，代码部分仅提供参考。
BUCT数据结构——图（拓扑排序、关键路径）
qq_41729237的博客
12-08 1145
文章目录问题 A: 邻接矩阵存储的图，节点的出度和入度计算(附加代码模式)问题 B: 算法7-12：有向无环图的拓扑排序问题 C: 有向图是否存在环？问题 D: 图-节点的最早发生时间问题 E: 图-节点的最迟发生时间问题 F: 图-图的关键路径 问题 A: 邻接矩阵存储的图，节点的出度和入度计算(附加代码模式) #include <iostream> #include <cstdio> using namespace std; #define MAX_SIZE 100 stru
问题 B: 邻接表存储的图转化为邻接矩阵存储的图-附加代码模式
weixin_65908362的博客
11-15 554
本题为附加代码模式，以上代码为自动附加在同学们提交的代码后面。在本题的提示中有代码框架，请同学们拷贝后，修改，再注释掉部分代码，最后提交。邻接表和邻接矩阵，是两种最重要的，也是最基础的图的存储方式。接下来n行，表示每个节点的信息，还有以该节点为起点可以到达的其他点的边信息。请编写程序将邻接表法存储的图，转化为邻接矩阵法存储的图，并输出。输入第一行为正整数n(n
实现图的邻接矩阵存储，将邻接矩阵转为邻接表。
王陈锋的博客
12-02 1696
前期提要 本代码的邻接矩阵的顶点设为v0、v1、v2、v3、v4、v5，从v0开始。 代码实现 #include<stdio.h> #include<malloc.h> typedef int InfoType; #define MAXV 100 //最大顶点个数 #define INF 32767 //INF表示无穷大 //以下定义邻接矩阵类型 typedef struct { int no;//顶点编号 InfoType info;//顶点其他信息
数据结构——邻接矩阵转邻接表（C语言）
weixin_42468092的博客
10-09 6624
将无向图的邻接矩阵存储转换为对应的邻接表存储 思路：遍历邻接矩阵，将有各个顶点关联的边所对应的顶点存储到邻接表所对应的顶点表的边表上，并连接起来。 #include<stdio.h> #include<stdlib.h> #define MaxVertexNum 100 #define ElemType int #define VertexType int typedef struct{//邻接矩阵存储 ElemType Vertices[MaxVertexNum]; .
严蔚敏版数据结构课本代码最最最完整版
10-22
严蔚敏版数据结构最最最完整版课本代码，懒得一篇一篇的传，有需要的自己下。（这是第二章的一个）
buct_java实验
02-06
或者使用ArrayList和HashMap等集合类，介绍数据结构和算法；甚至会包含多线程编程，以理解并发和同步的概念。 【buct】（北京化工大学）是中国知名的高等学府，其计算机科学教育在业界有着良好的声誉。这个Java实验...
BUCTWXServicesFront:BUCT轻触 小程序前端项目
05-04
BUCT轻触 小程序前端代码 全局主题适配指南 1. 关于全局主题适配 全局主题适配部分主要包括各个页面的顶栏部分的背景颜色和文字颜色，以及页面中与顶栏保持同步颜色的区域。 2. JS文件适配 在每一个页面的JS文件中的...
BUCT数字图像处理上机考试训练.pdf
12-12
3. **结构图片截图**：可能是程序运行过程中的中间结果或最终结果的展示，用于证明代码的正确性。 4. **其他图片文件**：可能包括原始图像、处理后的图像或其他辅助材料，以便于理解处理过程。 考试规定在指定的...
C语言：将邻接矩阵转换为邻接表算法
零小唬的博客
10-09 3026
将邻接矩阵转换为邻接表算法
设计算法，将已有用邻接矩阵存储的带权图转换成邻接表表示。
weixin_42365324的博客
05-08 1425
Question： 设计算法，将已有用邻接矩阵存储的带权图转换成邻接表表示。 给出邻接矩阵和邻接表存储结构如下： #define INFINITY 2000 //无穷大 #define MAX_VERTEX_NUM 20 //最多顶点个数 //邻接矩阵结构定义 Typedef struct ArcCell { int adj; ...
图3——把邻接矩阵转换为邻接表
凌空的桨
06-18 8450
【分析】这是哈工大的考研题。由于有向图和无向图的邻接存储结构不同，并与带权图的存储存在一定差别，这里给出有向图的邻接矩阵到邻接表的转换。 #include <stdio.h> #include <string.h> #include <malloc.h> #include <stdlib.h> #include <iostream> ...
邻接矩阵与邻接表的相互转换
m0_45920074的博客
12-09 9919
编写一个程序，输出带权图的邻接矩阵，并能将该邻接矩阵转换成相应的邻接表，并输出该邻接表，带权图如下图所示。 具体效果如下： 2.1.编写一个算法，实现由已知的邻接表产生对应的邻接矩阵，并输出。 具体效果如下： #include <iostream> #include<bits/stdc++.h> #define MAXV 100 #define MaxSize 100 #define INF 327676 using namespace std; typedef char .
邻接矩阵和邻接表存储的图的基本操作及完整代码
薛定谔的猫的博客
11-14 4071
文章目录构建带权图的邻接矩阵表示 构建带权图的邻接矩阵表示 题目描述： 设有一个带权图G，设计一个算法，输入n个顶点数据和e条边的顶点号i、j及其权值w，构建它的邻接矩阵表示。 实现代码： //顶点值转换为位置（数组下标） int getPos(MGraph G, VertexType v){ int i; for(i=0; i<G.vexnum; i++){ if(G.Vertex[i] == v){ break; }
数据结构，链表基本操作
nankeyimeng的博客
03-28 2235
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删
数据结构--图--图的数组存储表示,深度优先搜索遍历和广度优先搜索遍历
littlebeat123的专栏
08-08 4379
图有四种存储结构：数组，邻接表，十字链表，邻接多重表。下面以数组为存储结构来实现图的深度优先搜索遍历和广度优先搜索遍历。其中广度优先搜索遍历中有用到STL中的queue,注意头文件的包含。具体代码如下： //图的数组（邻接矩阵）存储表示和深度优先遍历 const int MAX_VERTEX_NUM=20; //最大顶点数 typedef enum {DG,DN,UDG,UDN} Graph
【18】输出字符菱形
2301_78786609的博客
07-19 287
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 108
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 186
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
python buctoj 列表数据清理
05-18
对于列表数据清理，可以使用Python的列表推导式。列表推导式是一种简洁的语法，可以根据已有列表中的元素生成新的列表。 以下是一个简单的示例，演示如何使用列表推导式清理列表数据： ```python # 原始数据列表 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值