数据结构学习第十七天

14:39:22 2019-09-01

学习

图的两种遍历方法:

①DFS 深度优先搜索(Depth First Search)

②BFS 广度优先搜索(Breadth First Search)  //利用队列实现广度优先

//邻接表实现 及 利用 邻接表 实现 深度优先搜索(DFS)

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
//表示图的两种方法
//邻接矩阵 G[N][N] N个顶点从0到N-1编号
//邻接表 表示
/*Graph Create();  //建立并返回空图
Graph InsertVertex(Graph G, Vertex v); //将v插入G
Graph InsertEdge(Graph G, Edge e); //将e插入G
void DFS(Graph G, Vertex v); //从顶点v出发深度优先遍历图G
void BFS(Graph G, Vertex v); //从顶点v出发宽度优先遍历图G
void ShortestPath(Graph G, Vertex v, int Dist[]); //计算图G中顶点v到任意其它顶点的最短距离
void MST(Graph G); //计算图G的最小生成树*/

//图的邻接表表示法
#define MaxVerterNum 100    //最大顶点数
#define INFINITY 65535        //
typedef int Vertex;            //顶点下标表示顶点
typedef int WeightType;        //边的权值
typedef char DataType;        //顶点存储的数据类型

//边的定义
typedef struct ENode* PtrToENode;
typedef PtrToENode Edge;
struct ENode
{
    Vertex V1, V2; //有向边<V1,V2>
    WeightType Weight;  //权重
};

//邻接点的定义
typedef struct AdjVNode* PtrToAdjVNode;
struct AdjVNode
{
    Vertex AdjV;  //邻接点下标
    WeightType Weight; //边权重
    PtrToAdjVNode Next; //指向下一个邻接点的指针
};

//顶点表头节点的定义
typedef struct Vnode
{
    PtrToAdjVNode FirstEdge;  //边表头指针
    DataType Data;            //存顶点的数据
}AdjList[MaxVerterNum];        //AdjList是邻接表类型

//图节点的定义
typedef struct GNode* PtrToGNode;
typedef PtrToGNode LGraph;
struct GNode
{
    int Nv;  //顶点数
    int Ne;  //边数
    AdjList G;  //邻接表
};

LGraph CreateGraph(int VertexNum)
{//初始化一个有VertexNum个顶点但没有边的图
    Vertex V;
    LGraph Graph;

    Graph = (LGraph)malloc(sizeof(struct GNode)); //建立图
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    //初始化邻接表头指针
    for (V = 0; V < Graph->Nv; V++)
        Graph->G[V].FirstEdge = NULL;
    return Graph;
}

void InsertEdge(LGraph Graph, Edge E)
{
    PtrToAdjVNode NewNode;
    //插入边<V1,V2>
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;

    //若是无向图 还要插入边<V2,V1>
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->Weight;
    NewNode->Next = Graph->G[E->V2].FirstEdge;
    Graph->G[E->V2].FirstEdge = NewNode;
}

LGraph BuildGraph()
{
    LGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;

    scanf("%d", &Nv);   /* 读入顶点个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */
    scanf("%d", &(Graph->Ne));  //读入边数
    if (Graph->Ne != 0) 
    { 
        E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点 */
        /* 读入边，格式为"起点 终点 权重"，插入邻接矩阵 */
        for (i = 0; i < Graph->Ne; i++)
        {
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight);
            InsertEdge(Graph, E);
        }
    }
    /* 如果顶点有数据的话，读入数据 */
    for (V = 0; V < Graph->Nv; V++)
        scanf(" %c", &(Graph->G[V].Data));
    return Graph;
}

//DFS 利用邻接表存储的图 实现 深度优先搜索
int visited[100];
void Visit(Vertex V)
{
    printf("访问顶点%d
", V);
}

// visited[]是全局变量 初始化为0
void DFS(LGraph Graph, Vertex V)   //以V为出发点访对邻接表存储的图进行DFS访问
{
    Visit(V);
    visited[V] = 1;

    PtrToAdjVNode W; //用来从某个点 出发访问
    for (W = Graph->G[V].FirstEdge; W; W = W->Next)
    {
        if (!visited[W->AdjV])   //若 W->Adjv未被访问 则递归访问
            DFS(Graph, W->AdjV);
    }
}

//邻接矩阵实现 及 利用 邻接矩阵 实现 广度优先搜索(BFS)

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
//表示图的两种方法
//邻接矩阵 G[N][N] N个顶点从0到N-1编号
//邻接表 表示
/*Graph Create();  //建立并返回空图
Graph InsertVertex(Graph G, Vertex v); //将v插入G
Graph InsertEdge(Graph G, Edge e); //将e插入G
void DFS(Graph G, Vertex v); //从顶点v出发深度优先遍历图G
void BFS(Graph G, Vertex v); //从顶点v出发宽度优先遍历图G
void ShortestPath(Graph G, Vertex v, int Dist[]); //计算图G中顶点v到任意其它顶点的最短距离
void MST(Graph G); //计算图G的最小生成树*/

//图的邻接矩阵表示法
#define MaxVerterNum 100    //最大顶点数
#define INFINITY 65535        //
typedef int Vertex;            //顶点下标表示顶点
typedef int WeightType;        //边的权值
typedef char DataType;        //顶点存储的数据类型

//边的定义
typedef struct ENode* PtrToENode;
typedef PtrToENode Edge;
struct ENode
{
    Vertex V1, V2; //有向边<V1,V2>
    WeightType Weight;  //权重
};

//图节点的定义
typedef struct GNode* PtrToGNode;
typedef PtrToGNode MGraph;   //以邻接矩阵存储的图类型
struct GNode
{
    int Nv;    //顶点数
    int Ne;    //边数
    WeightType G[MaxVerterNum][MaxVerterNum];   //邻接矩阵
    DataType Data[MaxVerterNum];            //存顶点的数据
};

MGraph CreateGraph(int VertexNum)
{//初始化一个有VerterNum个顶点但没有边的图
    Vertex V, W;
    MGraph Graph;

    Graph = (MGraph)malloc(sizeof(struct GNode));  //建立图
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    //初始化邻接矩阵
    for (V = 0; V < Graph->Nv; V++)
        for (W = 0; W < Graph->Nv; W++)
            Graph->G[V][W] = INFINITY;
    return Graph;
}

void InsertEdge(MGraph Graph, Edge E)
{
    //插入边<V1,V2>
    Graph->G[E->V1][E->V2] = E->Weight;
    //如果是无向图 还要插入边<V2,V1>
    Graph->G[E->V2][E->V1] = E->Weight;
}

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;

    scanf("%d", &Nv);  //读入顶点个数
    Graph = CreateGraph(Nv);  //初始化有Nv个顶点但没有边的图

    scanf("%d", &(Graph->Ne));  //读入边数
    if (Graph->Ne != 0)        //如果有边
    {
        E = (Edge)malloc(sizeof(struct  ENode));  //建立边节点
        //读入边 格式为 起点 终点 权重 插入邻接矩阵
        for (int i = 0; i < Graph->Ne; i++)
        {
            scanf("%d %d %d", &(E->V1), &(E->V2), &(E->Weight));
            InsertEdge(Graph, E);
        }
    }
    //若顶点有数据 读入数据
    for (V = 0; V < Graph->Nv; V++)
        scanf("%c", &(Graph->Data[V]));
    return Graph;
}

//邻接矩阵 实现广度优先搜索 BFS  利用队列
#define Size 50
int Queue[Size];
int Front=1;
int Rear=0;
int size;

int Succ(int Value)
{
    if (Value < Size)
        return Value;
    else
        return 0;
}

int IsEmpty()
{
    return (size == 0) ? 1 : 0;
}
int IsFull()
{
    return (size == Size) ? 1 : 0;
}
void EnQueue(int Element)
{
    Rear = Succ(Rear+1);
    Queue[Rear] = Element;
    size++;
}
int DeQueue()
{
    int Element = Queue[Front];
    Front = Succ(Front+1);
    size--;
    return Element;
}

//利用队列  与树的层序遍历相似
int visited[50];
int IsEdge(MGraph Graph, int V, int W)  //IsEdge 检查<V,W>是否是图Graph中的一条边
{
    return (Graph->G[V][W] < INFINITY) ? 1 : 0;
}
void Visit(Vertex V)
{
    printf("访问节点%d
", V);
}
void BFS(MGraph Graph, Vertex S)    //从节点S出发对以邻接矩阵存储的图Graph进行BFS搜索
{
    EnQueue(S);
    Visit(S);
    visited[S] = 1;

    while (!IsEmpty())
    {
        Vertex V=DeQueue();
        for (int W = 0; W < Graph->Nv; W++)
            if (!visited[W] && IsEdge(Graph, V, W))
            {
                EnQueue(W);
                Visit(W);
                visited[W] = 1;
            }
    }
}

PTA第15题 利用 邻接矩阵实现 图 并 用 深度优先搜索(DFS) 和 广度优先搜索(BFS) 输出数据

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
#define True 1
#define False 0
typedef struct ENode* Edge;
struct ENode
{
    int V1, V2;
};

typedef struct Graph* MGraph;
struct Graph
{
    int Nv;
    int Ne;
    int G[10][10];
};

MGraph CreateGraph(int MaxVertex)  //初始化一个没有边的图
{
    MGraph Graph = (MGraph)malloc(sizeof(struct Graph));
    Graph->Nv = MaxVertex;
    Graph->Ne = 0;
    for (int i = 0; i < Graph->Nv; i++)
        for (int j = 0; j < Graph->Nv; j++)
            Graph->G[i][j] =False;
    return Graph;
}

void Insert(MGraph Graph, Edge E)
{    //插入一个无向图
    Graph->G[E->V1][E->V2] = 1;
    Graph->G[E->V2][E->V1] = 1;
}

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    int V;
    int Nv;
    scanf("%d", &Nv);
    Graph = CreateGraph(Nv);
    scanf("%d
", &(Graph->Ne));
    if (Graph->Ne)
    {
        E = (Edge)malloc((sizeof(struct ENode)));
        for (int i = 0; i < Graph->Ne; i++)
        {
            scanf("%d %d
", &(E->V1), &(E->V2));
            Insert(Graph, E);
        }
    }
    return Graph;
}
//DFS 深度优先遍历
int visited1[11];
int IsEdge(MGraph Graph,int V, int W)
{
    return (Graph->G[V][W]==True)? 1 : 0;
}
void Visit(int V)
{
    printf("%d ", V);
}
void DFS(MGraph Graph, int V)  //默认从编号最小的点出发 即从V=0出发
{
    Visit(V);
    visited1[V] = 1;
    for (int i = 0; i < Graph->Nv; i++)
    {
        if (!visited1[i] && IsEdge(Graph, V, i))
            DFS(Graph, i);
    }
}
void ListComponetsForDFS(MGraph Graph)  //解决图不连通的问题
{
    for (int i = 0; i < Graph->Nv; i++)
    {
        if (!visited1[i])
        {
            printf("{ ");
            DFS(Graph, i);
            printf("}
");
        }
    }
}

//BFS 广度优先遍历
#define Size 11
int visited2[11];
int Queue[11];
int Front = 1;
int Rear = 0;
int size = 0;
int IsEmpty()
{
    return (size == 0) ? 1 : 0;
}
int Succ(int Value)
{
    if (Value < Size)
        return Value;
    else
        return 0;
}
void EnQueue(int V)
{
    Rear = Succ(Rear + 1);
    Queue[Rear] = V;
    size++;
}
int DeQueue()
{
    int V = Queue[Front];
    Front = Succ(Front + 1);
    size--;
    return V;
}
void BFS(MGraph Graph, int V)
{
    EnQueue(V);
    Visit(V);
    visited2[V] = 1;
    while (!IsEmpty())
    {
        int W=DeQueue();
        for (int i = 0; i < Graph->Nv; i++)
        {
            if (!visited2[i] && IsEdge(Graph, W, i))
            {
                EnQueue(i);
                Visit(i);
                visited2[i] = 1;
            }
        }
    }
}
void ListComponetsForBFS(MGraph Graph)
{
    for (int i = 0; i < Graph->Nv; i++)
    {
        if (!visited2[i])
        {
            printf("{ ");
            BFS(Graph, i);
            printf("}
");
        }
    }
}
int main()
{
    MGraph Graph = BuildGraph();
    ListComponetsForDFS(Graph);
    ListComponetsForBFS(Graph);
    return 0;
}

(os:稍微吐槽一句 我现在才认识什么是深度优先搜索和广度优先搜索 上学期就学的人是大佬)

PTA第16题 007逃生问题  其实也是建图 然后利用图的 深度优先搜索(DFS) 当然广度优先搜索也可以 

要计算节点之间的路径 我是新建了一个 存坐标的结构体 利用 元素在图里下标 和在 结构体下标一样 来进行计算

(os:最后找了快一小时bug 最后发现是因为我对递归的理解不过关 以后要抽空写写递归)

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
#include<math.h>
#define True 1
#define False 0
#define SizeOfPosition 100
float Length; //跳跃长度
struct  Position
{
    int x;
    int y;
}Positions[SizeOfPosition];

float Distance(float x1, float y1, float x2, float y2)
{
    return sqrt(((y2 - y1) * (y2 - y1)) + ((x2 - x1) * (x2 - x1)));
}

typedef struct ENode* Edge;
struct ENode
{
    int V1;
    int V2;
};

typedef struct Graph* MGraph;
struct Graph
{
    int Nv;
    int Ne;
    int G[100][100];
};

MGraph CreateGraph(int MaxVertex)
{
    MGraph Graph = (MGraph)malloc(sizeof(struct Graph));
    Graph->Nv = MaxVertex;
    Graph->Ne = 0;
    for (int i = 0; i < Graph->Nv; i++)
        for (int j = 0; j < Graph->Nv; j++)
            Graph->G[i][j] = 0;
    return Graph;
}

void Insert(MGraph Graph, Edge E)
{  
    Graph->G[E->V1][E->V2] = 1;
    Graph->G[E->V2][E->V1] = 1;
}

MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    int Nv;
    scanf("%d %f
", &Nv, &Length);
    Graph = CreateGraph(Nv);
    for (int i = 0; i < Graph->Nv; i++)
    {
        int x, y;
        scanf("%d %d
", &x, &y);
        Positions[i].x = x;
        Positions[i].y = y;
    }
    for(int i=0;i<Graph->Nv;i++)
        for (int j =i+1; j < Graph->Nv; j++)
        {
            float dis = Distance(Positions[i].x, Positions[i].y, Positions[j].x, Positions[j].y);
            if (dis <=Length)
            {
                E = (Edge)malloc(sizeof(struct ENode));
                E->V1 = i;
                E->V2 = j;
                Insert(Graph, E);
            }
        }
    return Graph;
}
int visited[100];
int IsEdge(MGraph Graph,int V,int W)
{
    return (Graph->G[V][W] == 1) ? 1 : 0;
}
int Judget(MGraph Graph,int V,float Length)  //深度优先遍历
{
    visited[V] = 1;
    if (Distance(0, 50, Positions[V].x, Positions[V].y) <= Length|| Distance(0, -50, Positions[V].x, Positions[V].y) <= Length
        || Distance(50,0, Positions[V].x, Positions[V].y) <= Length || Distance(-50, 0, Positions[V].x, Positions[V].y) <= Length)
        return 1;
    for (int i = 0; i < Graph->Nv; i++)
    {
        if (!visited[i] && IsEdge(Graph, V, i))
            if (Judget(Graph, i, Length))
                return 1;
    }
    return 0;
}
int ListComponets(MGraph Graph)
{
    for (int i = 0; i < Graph->Nv; i++)
    {
        if (!visited[i] && (Length+7.5)>=Distance(0, 0, Positions[i].x, Positions[i].y))
            if (Judget(Graph, i, Length))
                return 1;
    }
    return 0;
}
int main()
{
    MGraph Graph;
    Graph = BuildGraph();
    if (ListComponets(Graph))
        printf("Yes");
    else
        printf("No");
    return 0;
}