18版考研数据结构天勤课后习题代码-图【未完】

最新推荐文章于 2023-03-03 17:17:37 发布
最新推荐文章于 2023-03-03 17:17:37 发布
阅读量331 收藏 1
点赞数 1
分类专栏： 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36927714/article/details/100697410
版权

#include <iostream>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <stack>
using namespace std;
#define maxSize 101

/*
//求无向图中距离顶点V最远的一个顶点 天勤P190 例7-1
 typedef struct ENode  //边节点
{
    int adjvex;
    struct ENode *next;
}ENode;
typedef struct VNode  //顶点节点
{
    char data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];
typedef  struct Graph
{
    VNodeL adjlist;
    int Enum,Vnum;
}Graph;
int visited[maxSize];
void BFS(Graph g,int v)  //是把顶点序号入栈！！！
{
    visited[v]=1;
    int queue[maxSize];
    int front=1;
    int rear=1;
    queue[rear]=v;
    rear++;
    while(front!=rear)
    {
        v=queue[front];
        front++;
        ENode *s=g.adjlist[v].firstchild;
        while(s)
        {
            if(visited[s->adjvex]==0)
            {
                queue[rear++]=s->adjvex;
                visited[s->adjvex]=1;
            }
            s=s->next;
        }
    }
    cout<<v<<endl;  //队空时，v保存了遍历过程中最后一个节点
    return;
}
void Create(Graph &g)  //建图
{
    //cout<<"输出顶点数和边数："<<endl;
    int d1,d2;
    cin>>d1>>d2;
    g.Vnum=d1;
    g.Enum=d2;
    //cout<<"输入顶点信息"<<endl;
    //输入顶点信息
    for(int i=0;i<g.Vnum;i++)
    {
        int x;
        cin>>x;
        g.adjlist[i].data=x;
        g.adjlist[i].firstchild=NULL;  //把顶点节点指向边节点的指针初始化
    }
    //建立边表
    //cout<<"输入边（vi,vj)的下标"<<endl;
    for(int i=0;i<g.Enum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=x;
        q->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=q;
        ENode *s=(ENode*)malloc(sizeof(ENode));
        s->adjvex=y;
        s->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=s;
    }
}
int main()
{
    Graph g;
    Create(g);
    for(int i=0;i<g.Vnum;i++)
    {
        visited[i]=0;
    }
    
    BFS(g,2);
}
 
5
4
0 1 2 3 4
0 2
0 3
1 2
2 4
3
*/

 

/*
//判断无向图G是否是一棵树  天勤P190 例7-2  需要满足条件：如果满足遍历的定点数与图的顶点数相同并且访问的边数和等于顶点数-1的两倍，则说明是树，否则不是树。
typedef struct VNode
{
    char data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;
typedef struct Graph
{
    int Enum,Vnum;
    VNodeL adjlist;
}Graph;
int visited[maxSize];
void DFS(Graph g,int v,int &vn,int &en)
{
    visited[v]=1;
    ENode *p=g.adjlist[v].firstchild;
    vn++;   //注意数顶点的语句的位置
    while(p)
    {
        en++;   //注意数边的语句的位置
        if(visited[p->adjvex]==0)
        {
            DFS(g,p->adjvex,vn,en);
        }
        p=p->next;
    }
}
int Judge(Graph g,int vn,int en)
{
    if(vn==g.Vnum&&en/2==vn-1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
void Create(Graph &g)
{
    cin>>g.Vnum>>g.Enum;
    for(int i=0;i<g.Vnum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.Enum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=x;
        p->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
int main()
{
    Graph g;
    Create(g);
    for(int i=0;i<g.Vnum;i++)
        visited[i]=0;
    int vn=0,en=0;
    DFS(g,0,vn,en);
    cout<<vn<<" "<<en<<endl;
    int d=Judge(g,vn,en);
    cout<<d<<endl;
}

5
4
0 1 2 3 4
0 3
0 2
1 2
2 4
 
 5
 5
 0 1 2 3 4
 0 1
 0 2
 0 3
 1 2
 2 4
 */


/*
//判断顶点i和顶点j之间是否有路径 天勤P192 例7-3
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;

typedef struct VNode
{
    char data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];

typedef struct Graph
{
    VNodeL adjlist;
    int VNum,ENum;
}Graph;
int visited[maxSize];
void Create(Graph &g)   //一定记得不要忘记引用号！！！
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=x;
        p->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
int DFS(Graph g,int i,int j)
{
    visited[i]=1;
    ENode *s=g.adjlist[i].firstchild;
    while(s)
    {
        if(visited[s->adjvex]==0)
        {
            if(s->adjvex==j)
            {
                return 1;   //有路径
            }
            DFS(g,s->adjvex,j);
        }
        s=s->next;
    }
    return 0;
}
int main()
{
    Graph g;
    Create(g);
    int i=0;
    int j=3;
    for(int i=0;i<g.VNum;i++)
    {
        visited[i]=0;
    }
    int d=0;
    d=DFS(g,i,j);
 
    if(visited[j]==1)
    {
        cout<<"有路径";
    }
    else
    {
        cout<<"不存在路径";
    }
 
    cout<<d<<endl;
}

5
5
0 1 2 3 4
0 1
0 2
0 3
1 2
2 4
 
 5
 5
 0 1 2 3 4
 0 1
 0 2
 1 2
 2 4
 1 4
 */


/*
//使用BFS和DFS遍历图   天勤P197 例7-5
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];
typedef struct Graph
{
    int VNum,ENum;
    VNodeL adjlist;
}Graph;
int visited[maxSize];
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=1;i<=g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=1;i<=g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=x;
        p->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
void BFS(Graph g,int v)
{
    int queue[maxSize];
    int front=1;
    int rear=1;
    queue[rear++]=v;
    visited[v]=1;
    while(front!=rear)
    {
        v=queue[front++];
        ENode *p=g.adjlist[v].firstchild;
        while(p)
        {
            if(visited[p->adjvex]==0)
            {
                visited[p->adjvex]=1;
                cout<<p->adjvex<<" ";
                queue[rear++]=p->adjvex;
            }
            p=p->next;
        }
    }
}

void DFS(Graph g,int v)
{
    visited[v]=1;
    ENode *p=g.adjlist[v].firstchild;
    while(p)
    {
        if(visited[p->adjvex]==0)
        {
            visited[p->adjvex]=1;
            cout<<p->adjvex<<" ";
            DFS(g,p->adjvex);
        }
        p=p->next;
    }
    
}
int main()
{
    Graph g;
    Create(g);
    for(int i=1;i<=g.VNum;i++)
    {
        visited[i]=0;
    }
    cout<<1<<" ";
    DFS(g,1);
    cout<<endl;
    for(int i=1;i<=g.VNum;i++)
    {
        visited[i]=0;
    }
    cout<<1<<" ";
    BFS(g,1);
    cout<<endl;
}
*/

/*
//判断有向图中是否存在vi到vj的路径  天勤P213。真题仿造1
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;

typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];

typedef struct Graph
{
    VNodeL adjlist;
    int VNum,ENum;
}Graph;
int visited[maxSize];
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=y;
        p->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=x;
        q->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=q;
    }
}
int DFS(Graph g,int i,int j)
{
    visited[i]=1;
    ENode *p=g.adjlist[i].firstchild;
    while(p)
    {
        if(visited[p->adjvex]==0)
        {
            if(p->adjvex==j)
            {
                return 1;
            }
            visited[p->adjvex]=1;
            DFS(g,p->adjvex,j);
        }
        p=p->next;
    }
    return 0;
}
int main()
{
    Graph g;
    Create(g);
    for(int i=1;i<=g.VNum;i++)
    {
        visited[i]=0;
    }
    int x=1,y=4;
    int d=DFS(g,x,y);
    cout<<d<<endl;
}
*/


/*
//判断有向图中是否有根节点  真题仿造 2 天勤P213
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;

typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];

typedef struct Graph
{
    VNodeL adjlist;
    int ENum,VNum;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *q=(ENode*)malloc(sizeof(ENode));   //有向图
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
int visited[maxSize];
int d;
int DFS(Graph g,int v)
{
    visited[v]=1;
    ENode *p=g.adjlist[v].firstchild;
    d++;
    while(p)
    {
       if(visited[p->adjvex]==0)
       {
           DFS(g,p->adjvex);
       }
        p=p->next;
    }
    return d;
}
int main()
{
    Graph g;
    Create(g);
    for(int i=0;i<g.VNum;i++)
    {
        d=0;
        for(int j=0;j<g.VNum;j++)   //记得每次遍历之前要把visited数组初始化
        {
            visited[j]=0;
        }
        d=DFS(g,i);
        //cout<<d<<endl;
        if(d==g.VNum)
        {
            cout<<i<<endl;
        }
    }
}

 3
 3
 0 1 2
 0 1
 1 2
 2 0
 
 */


/*
//从图的邻接表转换为图的邻接矩阵。天勤P218 （7）
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];
typedef struct Graph
{
    VNodeL adjlist;
    int VNum,ENum;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=x;
        p->next=g.adjlist[y].firstchild;
        g.adjlist[y].firstchild=p;
        ENode *q=(ENode*)malloc(sizeof(ENode));
        q->adjvex=y;
        q->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=q;
    }
}
void Transfer(Graph g,int matrix[][maxSize])
{
    for(int i=0;i<g.VNum;i++)
    {
        ENode *p=g.adjlist[i].firstchild;
        while(p)
        {
            matrix[i][p->adjvex]=1;
            p=p->next;
        }
    }
}
int main()
{
    Graph g;
    Create(g);
    int matrix[maxSize][maxSize];
    for(int i=0;i<g.VNum;i++)
    {
        for(int j=0;j<g.VNum;j++)
        {
            matrix[i][j]=0;
        }
    }
    Transfer(g,matrix);
    for(int i=0;i<g.VNum;i++)
    {
        for(int j=0;j<g.VNum;j++)
        {
            cout<<matrix[i][j]<<" ";
        }
        cout<<endl;
    }
}

4
3
0 1 2 3
0 1
1 2
2 3
*/

/*
//求顶点k的入度  天勤P218 （8）
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;
typedef struct Graph
{
    VNodeL adjlist;
    int VNum,ENum;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=y;
        p->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=p;
    }
}
int Count(Graph g,int v,int k)
{
    int d=0;
    ENode *p=g.adjlist[v].firstchild;
    while(p)
    {
        if(p->adjvex==k)
        {
            d++;
        }
        p=p->next;
    }
    return d;
}
int main()
{
    Graph g;
    Create(g);
    int d=0;
    int k=2;
    for(int i=0;i<g.VNum;i++)
    {
        d+=Count(g,i,k);
    }
    cout<<d<<endl;
}
4
5
0 1 2 3
0 1
0 2
0 3
1 2
3 2
*/

/*
//DFS非递归算法
typedef struct ENode
{
    int adjvex;
    struct ENode *next;
}ENode;
typedef struct VNode
{
    int data;
    struct ENode *firstchild;
}VNode,VNodeL[maxSize];
typedef struct Graph
{
    VNodeL adjlist;
    int ENum,VNum;
}Graph;
void Create(Graph &g)
{
    cin>>g.VNum>>g.ENum;
    for(int i=0;i<g.VNum;i++)
    {
        cin>>g.adjlist[i].data;
        g.adjlist[i].firstchild=NULL;
    }
    for(int i=0;i<g.ENum;i++)
    {
        int x,y;
        cin>>x>>y;
        ENode *p=(ENode*)malloc(sizeof(ENode));
        p->adjvex=y;
        p->next=g.adjlist[x].firstchild;
        g.adjlist[x].firstchild=p;
    }
}
int visited[maxSize];
void DFS(Graph g,int v)
{
    int stack[maxSize];
    int top=-1;
    visited[v]=1;
    stack[++top]=v;
    while(top!=-1)
    {
        v=stack[top];
        ENode *q=g.adjlist[v].firstchild;
        while(q&&visited[q->adjvex]==1)
        {
              q=q->next;
        }
        if(q==NULL)  //若q到达链表尾部，说明当前顶点的所有点都访问完毕，当前顶点出栈
            --top;
        else  //否则访问当前邻接点并入栈
        {
            cout<<q->adjvex<<" ";
            visited[q->adjvex]=1;
            stack[++top]=q->adjvex;
        }
    }
}
int main()
{
    Graph g;
    Create(g);
    for(int i=0;i<g.VNum;i++)
        visited[i]=0;
    cout<<0<<" ";
    DFS(g,0);
}

6
6
0 1 2 3 4 5
0 4
4 3
3 5
3 2
2 1
1 0
0 4 3 2 1 5
*/

//计算全省畅通需要的最低成本  最小生成树  P天勤218 2 （1）

 

 

 

努力努力再努力0.0
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode 101. 对称二叉树（简单）递归 和 迭代
Perrysky的博客
04-16 206
题目描述： 给定一个二叉树，检查它是否是镜像对称的。 例如，二叉树[1,2,2,3,4,4,3] 是对称的。 1 / \ 2 2 / \ / \ 3 4 4 3 但是下面这个[1,2,2,null,3,null,3] 则不是镜像对称的: 1 / \ 2 2 \ \ 3 3 进阶： 你可以运用递归和迭代...
天勤数据结构
08-15
解压后,包含两个PDF文件,天勤数据结构近两年的版本(2018版/2019版),资源不用介绍,你们都有备而来,一起学习吧
java实现循环队列
weixin_34351321的博客
06-25 235
别的不多说直接上代码: class CircleArray{ private int maxSize; // 表示数组的最大容量 //front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素 //front 的初始值 = 0 private int front; //rear 变量的含义做一个调整：...
数据结构与算法基础（王卓）（12）：队列的定义及其基础操作（解决假上溢的方法，循环队列解决队满时判断方法，链队和循环队列的初始化等）
Zz_zzzzzzz__的博客
03-03 1404
循环队列： 解决假上溢的方法：引入循环队列（判断是否溢出） 循环队列解决队满时判断方法：少用一个元素空间 前置条件： 初始化： 求长度: 取队头元素： 入队和出队： 链式队列： 前置条件： 初始化 销毁 入队： 出队： 求链队列的队头元素：
关于堆栈与队列使用的小思考(1)
lifeidgp的专栏
10-06 1153
关于堆栈与队列使用的小思考：从经典的问题开始 1.走迷宫问题：   首先还是说说问题大概情况，走迷宫问题从入口出出发，顺着周围可走的通道向前探索，目的很简单到达出口就行了.估计你也许听得不耐烦了，好吧，接下来让我们直截了当地说明它在C语言里面的数据描述。              我们用一个二维的数组表示的矩阵来表示一个平面上的迷宫，其中数组的每一个元素代表了一个通道，如果值为1则表示有障碍，为0
18版考研数据结构天勤课后习题全部代码-栈和队列.cpp
09-08
18版考研数据结构天勤课后习题全部代码-栈和队列，用于考研复习
18版考研数据结构天勤课后习题全部代码-线性表.cpp
09-08
18版考研数据结构天勤课后习题全部代码-线性表，用于学生考研参考
天勤论坛-数据结构考研试题1800题集锦（含答案）
03-03
天勤论坛_数据结构考研试题1800题集锦（含答案）
2020 天勤数据结构 高分笔记 + 习题
03-31
数据结构 考研 官方用书 pdf高清版，另有习题。
天勤2019数据结构全套视频 天勤考研资料视频下载
09-25
天勤2019数据结构全套视频，包含基础知识、串、图、排序、数组、矩阵、广义表、查找、栈和队列、树、算法、线性表等
天勤论坛数据结构1800题
03-16
天勤论坛出的数据结构1800题，考研408必备，可以一刷。
2019天勤数据结构
09-05
简单易懂的数据结构PDF，适合零基础理解晦涩难懂的数据 结构
天勤2019数据结构高分笔记.rar
09-19
天勤笔记四门专业课中数据结构的高清pdf版本
天勤2019数据结构无水印可打印
12-11
天勤2019数据结构计算机考研复习指导电子版PDF 天勤2019计算机组成原理计算机考研复习指导无水印版. 天勤2019年计算机网络(高清版)
天勤论坛_数据结构考研试题1800题集锦（含答案
03-25
天勤论坛_数据结构考研试题1800题集锦（含答案）离线版，适合课后来练习
数据结构-天勤
qq_41497658的博客
08-17 539
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
《数据结构》天勤和王道 第五章 树
壹的博客
04-30 1938
《数据结构》天勤和王道 第五章 树王道部分1. 树的基本概念2. 树的常考性质 王道部分 1. 树的基本概念 2. 树的常考性质
考研天勤 数据结构 图（自用回顾）
qq_52483547的博客
10-10 1023
数据结构-图的相关算法
数据结构-天勤习题1
gaoya7305的博客
10-18 464
数据结构天勤习题
天勤考研算法练习赛题目-天勤考研算法练习赛（2）
最新发布
09-09
天勤考研算法练习赛题目-天勤考研算法练习赛（2）是一道编程题，题目的主要内容是判断给定的物品清单中哪些物品可以被"变出"，哪些物品不能被"变出"。物品的命名规则如下： 1. 物品的名称仅由字母（大小写均可）和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值