算法设计与分析—第五章搜索法作业-必做：图的宽度优先搜索与深度优先搜索(头歌实验)

@单纯很吃货

已于 2023-10-31 18:36:25 修改

阅读量782

点赞数 9

分类专栏：头歌实验答案文章标签：宽度优先算法深度优先

于 2023-05-08 20:51:03 首次发布

本文链接：https://blog.csdn.net/qq_62524881/article/details/130566999

版权

头歌实验答案专栏收录该内容

19 篇文章 37 订阅

订阅专栏

第1关：实现图的宽度优先遍历

任务描述

本关任务：请你实现 graph.cpp 里的int Graph_WidthFirst(Graph*g, int start, Edge* tree)函数。注意遵守约定：编号小的优先入队列。

参考代码：

//Graph

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Graph.h"
///
Graph* Graph_Create(int n)
{
	Graph* g=(Graph*)malloc(sizeof(Graph));
	g->n=n;
	g->vetex=(char**)malloc(sizeof(char*)*n);
	int i;
	for (i=0; i<n; i++) g->vetex[i] = NULL;
	g->adj=(int*)malloc(sizeof(int)*n*n);
	int j;
	for(i=0; i<n; i++) {
		for(j=0; j<n; j++) {
			g->adj[i*n+j]=0;
		}
	}
	return g;
}

void Graph_Free(Graph* g)
{
	free(g->adj);
	int i;
	for (i=0; i<g->n; i++) free(g->vetex[i]);
	free(g->vetex);
	free(g);
}

int Graph_WidthFirst(Graph*g, int start, Edge* tree)
//从start号顶点出发宽度优先遍历，（编号从0开始）
//返回访问到的顶点数，
//tree[]输出遍历树
//返回的tree[0]是(-1, start), 
//真正的遍历树保存在tree[1..return-1], return是返回值
//顶点的访问次序依次为tree[0].to, tree[1].to,  ..., tree[return-1].to
//输入时，tree[]的长度至少为顶点数
//返回值是从start出发访问到的顶点数
{
	const int MAX=1000;
	Edge queue[MAX];
	int head=0, tail=0;
#define In__(a,b)  {queue[tail].from=a; queue[tail].to=b; tail=(tail+1)%MAX;}
#define Out__(a,b)  {a=queue[head].from; b=queue[head].to; head=(head+1)%MAX;}
#define QueueNotEmpty (head!=tail?1:0)///
#define HasEdge(i,j)  (g->adj[(i)*g->n+(j)]==1)

	char* visited=(char*)malloc(sizeof(char)*g->n);
	memset(visited, 0, sizeof(char)*g->n);

	int parent=-1;  
	int curr=start;
	In__(parent, curr); 
	int k=0; //已经访问的结点数
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
    while(QueueNotEmpty) 
	{
		Out__(parent,curr);//out是输出值，不需要预先给他值，当函数执行完毕后可以从这个变量获取输出的数据
		if(visited[curr])
		continue;
		visited[curr]=1;
		tree[k].from=parent;
		tree[k].to=curr;
		k++;
		int j;
		for(j=0;j<g->n;j++)
		{
			if(HasEdge(curr,j)&&!visited[j])
			In__(curr,j);
		}
	}

    /*****END*******/
	return k;
#undef In__///
#undef Out__///
#undef QueueNotEmpty
#undef HasEdge
}

第2关：实现图的深度优先遍历

任务描述

本关任务：实现 graph.cpp 里的函数int Graph_DepthFirst(Graph*g, int start, Edge* tree)。注意遵守约定：编号大的先进栈。

参考代码：

//Graph

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Graph.h"
///
Graph* Graph_Create(int n)
{
	Graph* g=(Graph*)malloc(sizeof(Graph));
	g->n=n;
	g->vetex=(char**)malloc(sizeof(char*)*n);
	int i;
	for (i=0; i<n; i++) g->vetex[i] = NULL;
	g->adj=(int*)malloc(sizeof(int)*n*n);
	int j;
	for(i=0; i<n; i++) {
		for(j=0; j<n; j++) {
			g->adj[i*n+j]=0;
		}
	}
	return g;
}

void Graph_Free(Graph* g)
{
	free(g->adj);
	int i;
	for (i=0; i<g->n; i++) free(g->vetex[i]);
	free(g->vetex);
	free(g);
}

int Graph_DepthFirst(Graph*g, int start, Edge* tree)
//从start号顶点出发深度优先遍历，（编号从开始）
//返回访问到的顶点数，
//tree[]输出遍历树
//返回的tree[0]是(-1, start), 
//真正的遍历树保存在tree[1..return-1], return是返回值
//顶点的访问次序依次为tree[0].to, tree[1].to, ..., tree[return-1].to
//输入时，tree[]的长度至少为顶点数
//返回值是从start出发访问到的顶点数
{
	/*请在BEGIN和END之间实现你的代码*/
    /*****BEGIN*****/
    const int MAX=1000;
    Edge stack[MAX];
    int top=-1;
#define In__(a,b)  {top++;stack[top].from=a; stack[top].to=b;}
#define Out__(a,b)  {a=stack[top].from; b=stack[top].to;top--;}
#define StackNotEmpty (top>=0?1:0)
#define HasEdge(i,j)  (g->adj[(i)*g->n+(j)]==1)
    char* visited=(char*)malloc(sizeof(char)*g->n);
    memset(visited, 0, sizeof(char)*g->n);
    int parent=-1; 
    int curr=start;
    In__(parent, curr); 
    int k=0; 
    while(StackNotEmpty) 
    {
       Out__(parent, curr);
        if (visited[curr])
            continue; 
        visited[curr]=1; 
            tree[k].from=parent;
            tree[k].to=curr;
            k++;
            int j;
            for(j=g->n-1;j>=0;j--)
            {
                if(HasEdge(curr,j)&&!visited[j])
                In__(curr,j);
            }
    }
    return k;
    #undef In__
#undef Out__
#undef QueueNotEmpty
#undef HasEdge

    /*****END*******/
}