深度优先搜索

最新推荐文章于 2023-10-16 00:05:41 发布
最新推荐文章于 2023-10-16 00:05:41 发布
阅读量138 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jstana/article/details/92591441
版权 
#include <stdio.h>
#include "stdlib.h"
#define vertexnum 10
typedef struct node{
    int vertex;
    struct node *next;
}*graph;

struct node head[vertexnum];
int visited[vertexnum];

//以邻接表形式存储
void Creat_Graph(int vertex1,int vertex2){
    graph pointer,new_p;
    new_p = (graph)malloc(sizeof(struct node));
    if(new_p != NULL){
        pointer = &(head[vertex1]);
        new_p = vertex2;
        new_p->next = NULL;
        while (pointer->next != NULL){
            pointer=pointer->next;
        }
        pointer->next=new_p;
    }
}
//打印邻接点
void Print_graph(struct node *head){
    graph pointer;
    pointer=head->next;
    while(pointer != NULL){
        printf("[%d]",pointer->vertex);
        pointer=pointer->next;
    }
    printf("\n");
}

//深度遍历
void DFS(int vertex){
    graph pointer;
    visited[vertex] = 1;
    printf("[%d]==>",vertex);
    pointer=&(head[vertex]).next;
    while (pointer !=NULL){
        if(visited[vertex]==0)
            DFS(pointer->vertex);
        pointer=pointer->next;
    }

}



int main() {
    int i,j,side,nodenum;
    int vertex;
    int node[100];//存一百组数据  也就是50条边
    printf("please input the number of node:\n");
    scanf("%d",&nodenum);
    printf("please input the number of side:\n");
    scanf("%d",&side);
    for(i = 0,j=1;(i/2+1)<=side;i+=2,j+=2){
        scanf("%d%d",&node[i],&node[j]);
        Creat_Graph(node[i],node[j]);
    }#include <stdio.h>
#include "stdlib.h"
#define vertexnum 10
typedef struct node{
    int vertex;
    struct node *next;
}*graph;

struct node head[vertexnum];
int visited[vertexnum];

//以邻接表形式存储
void Creat_Graph(int vertex1,int vertex2){
    graph pointer,new_p;
    new_p = (graph)malloc(sizeof(struct node));
    if(new_p != NULL){
        pointer = &(head[vertex1]);
        new_p = vertex2;
        new_p->next = NULL;
        while (pointer->next != NULL){
            pointer=pointer->next;
        }
        pointer->next=new_p;
    }
}
//打印邻接点
void Print_graph(struct node *head){
    graph pointer;
    pointer=head->next;
    while(pointer != NULL){
        printf("[%d]",pointer->vertex);
        pointer=pointer->next;
    }
    printf("\n");
}

//深度遍历
void DFS(int vertex){
    graph pointer;
    visited[vertex] = 1;
    printf("[%d]==>",vertex);
    pointer=&(head[vertex]).next;
    while (pointer !=NULL){
        if(visited[vertex]==0)
            DFS(pointer->vertex);
        pointer=pointer->next;
    }

}



int main() {
    int i,j,side,nodenum;
    int vertex;
    int node[100];//存一百组数据  也就是50条边
    printf("please input the number of node:\n");
    scanf("%d",&nodenum);
    printf("please input the number of side:\n");
    scanf("%d",&side);
    for(i = 0,j=1;(i/2+1)<=side;i+=2,j+=2){
        scanf("%d%d",&node[i],&node[j]);
        Creat_Graph(node[i],node[j]);
    }
    for(i=1;i<=nodenum;i++){
        head[i].vertex=i;
        head[i].next=NULL;
    }
    for(i=1;i<=nodenum;i++)
        visited[i]=0;
    printf("graph\n");
    for (i=1;i<=nodenum;i++){
        printf("vertex[%d]: ",i);
        Print_graph(&head[i]);
    }
    printf("\nPlease enter the start node:");
    scanf("%d",&vertex);
    printf("\nthe depth of the graph is (starting from node %d):\n",vertex);
    printf(" [开始]==>");
    DFS(vertex);  //首先从结点1开始
    printf(" [结束] \n\n");


    return 0;
}
    for(i=1;i<=nodenum;i++){
        head[i].vertex=i;
        head[i].next=NULL;
    }
    for(i=1;i<=nodenum;i++)
        visited[i]=0;
    printf("graph\n");
    for (i=1;i<=nodenum;i++){
        printf("vertex[%d]: ",i);
        Print_graph(&head[i]);
    }
    printf("\nPlease enter the start node:");
    scanf("%d",&vertex);
    printf("\nthe depth of the graph is (starting from node %d):\n",vertex);
    printf(" [开始]==>");
    DFS(vertex);  //首先从结点1开始
    printf(" [结束] \n\n");


    return 0;
}

/**
 * C: 邻接表表示的"无向图(List Undirected Graph)"
 *
 * @author skywang
 * @date 2014/04/18
 */

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

#define MAX 100
#define isLetter(a)  ((((a)>='a')&&((a)<='z')) || (((a)>='A')&&((a)<='Z')))
#define LENGTH(a)  (sizeof(a)/sizeof(a[0]))

// 邻接表中表对应的链表的顶点
typedef struct _ENode
{
    int ivex;                   // 该边所指向的顶点的位置
    struct _ENode *next_edge;   // 指向下一条弧的指针
}ENode, *PENode;

// 邻接表中表的顶点
typedef struct _VNode
{
    char data;              // 顶点信息
    ENode *first_edge;      // 指向第一条依附该顶点的弧
}VNode;

// 邻接表
typedef struct _LGraph
{
    int vexnum;             // 图的顶点的数目
    int edgnum;             // 图的边的数目
    VNode vexs[MAX];
}LGraph;

/*
 * 返回ch在matrix矩阵中的位置
 */
static int get_position(LGraph g, char ch)
{
    int i;
    for(i=0; i<g.vexnum; i++)
        if(g.vexs[i].data==ch)
            return i;
    return -1;
}

/*
 * 读取一个输入字符
 */
static char read_char()
{
    char ch;

    do {
        ch = getchar();
    } while(!isLetter(ch));

    return ch;
}

/*
 * 将node链接到list的末尾
 */
static void link_last(ENode *list, ENode *node)
{
    ENode *p = list;

    while(p->next_edge)
        p = p->next_edge;
    p->next_edge = node;
}

/*
 * 创建邻接表对应的图(自己输入)
 */
LGraph* create_lgraph()
{
    char c1, c2;
    int v, e;
    int i, p1, p2;
    ENode *node1, *node2;
    LGraph* pG;

    // 输入"顶点数"和"边数"
    printf("input vertex number: ");
    scanf("%d", &v);
    printf("input edge number: ");
    scanf("%d", &e);
    if ( v < 1 || e < 1 || (e > (v * (v-1))))
    {
        printf("input error: invalid parameters!\n");
        return NULL;
    }
 
    if ((pG=(LGraph*)malloc(sizeof(LGraph))) == NULL )
        return NULL;
    memset(pG, 0, sizeof(LGraph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = v;
    pG->edgnum = e;
    // 初始化"邻接表"的顶点
    for(i=0; i<pG->vexnum; i++)
    {
        printf("vertex(%d): ", i);
        pG->vexs[i].data = read_char();
        pG->vexs[i].first_edge = NULL;
    }

    // 初始化"邻接表"的边
    for(i=0; i<pG->edgnum; i++)
    {
        // 读取边的起始顶点和结束顶点
        printf("edge(%d): ", i);
        c1 = read_char();
        c2 = read_char();

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);

        // 初始化node1
        node1 = (ENode*)malloc(sizeof(ENode));
        node1->ivex = p2;
        // 将node1链接到"p1所在链表的末尾"
        if(pG->vexs[p1].first_edge == NULL)
          pG->vexs[p1].first_edge = node1;
        else
            link_last(pG->vexs[p1].first_edge, node1);
        // 初始化node2
        node2 = (ENode*)malloc(sizeof(ENode));
        node2->ivex = p1;
        // 将node2链接到"p2所在链表的末尾"
        if(pG->vexs[p2].first_edge == NULL)
          pG->vexs[p2].first_edge = node2;
        else
            link_last(pG->vexs[p2].first_edge, node2);
    }

    return pG;
}

/*
 * 创建邻接表对应的图(用已提供的数据)
 */
LGraph* create_example_lgraph()
{
    char c1, c2;
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    char edges[][2] = {
        {'A', 'C'}, 
        {'A', 'D'}, 
        {'A', 'F'}, 
        {'B', 'C'}, 
        {'C', 'D'}, 
        {'E', 'G'}, 
        {'F', 'G'}}; 
    int vlen = LENGTH(vexs);
    int elen = LENGTH(edges);
    int i, p1, p2;
    ENode *node1, *node2;
    LGraph* pG;


    if ((pG=(LGraph*)malloc(sizeof(LGraph))) == NULL )
        return NULL;
    memset(pG, 0, sizeof(LGraph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = vlen;
    pG->edgnum = elen;
    // 初始化"邻接表"的顶点
    for(i=0; i<pG->vexnum; i++)
    {
        pG->vexs[i].data = vexs[i];
        pG->vexs[i].first_edge = NULL;
    }

    // 初始化"邻接表"的边
    for(i=0; i<pG->edgnum; i++)
    {
        // 读取边的起始顶点和结束顶点
        c1 = edges[i][0];
        c2 = edges[i][1];

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);

        // 初始化node1
        node1 = (ENode*)malloc(sizeof(ENode));
        node1->ivex = p2;
        // 将node1链接到"p1所在链表的末尾"
        if(pG->vexs[p1].first_edge == NULL)
          pG->vexs[p1].first_edge = node1;
        else
            link_last(pG->vexs[p1].first_edge, node1);
        // 初始化node2
        node2 = (ENode*)malloc(sizeof(ENode));
        node2->ivex = p1;
        // 将node2链接到"p2所在链表的末尾"
        if(pG->vexs[p2].first_edge == NULL)
          pG->vexs[p2].first_edge = node2;
        else
            link_last(pG->vexs[p2].first_edge, node2);
    }

    return pG;
}

/*
 * 深度优先搜索遍历图的递归实现
 */
static void DFS(LGraph G, int i, int *visited)
{
    int w;
    ENode *node;

    visited[i] = 1;
    printf("%c ", G.vexs[i].data);
    node = G.vexs[i].first_edge;
    while (node != NULL)
    {
        if (!visited[node->ivex])
            DFS(G, node->ivex, visited);
        node = node->next_edge;
    }
}

/*
 * 深度优先搜索遍历图
 */
void DFSTraverse(LGraph G)
{
    int i;
    int visited[MAX];       // 顶点访问标记

    // 初始化所有顶点都没有被访问
    for (i = 0; i < G.vexnum; i++)
        visited[i] = 0;

    printf("DFS: ");
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
            DFS(G, i, visited);
    }
    printf("\n");
}

/*
 * 广度优先搜索（类似于树的层次遍历）
 */
void BFS(LGraph G)
{
    int head = 0;
    int rear = 0;
    int queue[MAX];     // 辅组队列
    int visited[MAX];   // 顶点访问标记
    int i, j, k;
    ENode *node;

    for (i = 0; i < G.vexnum; i++)
        visited[i] = 0;

    printf("BFS: ");
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
        {
            visited[i] = 1;
            printf("%c ", G.vexs[i].data);
            queue[rear++] = i;  // 入队列
        }
        while (head != rear) 
        {
            j = queue[head++];  // 出队列
            node = G.vexs[j].first_edge;
            while (node != NULL)
            {
                k = node->ivex;
                if (!visited[k])
                {
                    visited[k] = 1;
                    printf("%c ", G.vexs[k].data);
                    queue[rear++] = k;
                }
                node = node->next_edge;
            }
        }
    }
    printf("\n");
}

/*
 * 打印邻接表图
 */
void print_lgraph(LGraph G)
{
    int i,j;
    ENode *node;

    printf("List Graph:\n");
    for (i = 0; i < G.vexnum; i++)
    {
        printf("%d(%c): ", i, G.vexs[i].data);
        node = G.vexs[i].first_edge;
        while (node != NULL)
        {
            printf("%d(%c) ", node->ivex, G.vexs[node->ivex].data);
            node = node->next_edge;
        }
        printf("\n");
    }
}

void main()
{
    LGraph* pG;

    // 自定义"图"(自己输入数据)
    //pG = create_lgraph();
    // 采用已有的"图"
    pG = create_example_lgraph();

    // 打印图
    print_lgraph(*pG);
    DFSTraverse(*pG);
    BFS(*pG);
}
buer103
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++深度优先搜索的实现方法
12-26
本文实例讲述了图的遍历中深度优先搜索的C++实现方法，是一种非常重要的算法，具体实现方法如下： 首先，图的遍历是指从图中的某一个顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次。...
迷宫问题c语言 深度优先搜索
07-23
迷宫问题c语言 深度优先搜索
深度优先搜索（DFS）（算法笔记）
Arabot_的博客
03-22 7808
深度优先搜索是一种枚举所有完整路径以遍历所有情况的搜索方法，总是以“深度”作为前进的关键词。实现方式是有很多，最常见的是递归。深度优先搜索属于搜索问题的一种，当问题可以被描述为“路径搜索”时，就可以采用搜素问题的所有解的方式来进行解决，所以DFS本质还是暴力。深度搜索具有两个关键词，即“岔道口”和“死胡同”，这两个词来源于迷宫问题，这也是搜索问题最原始的表现。当碰到岔道口时，总是以“深度”作为前进的关键词，不碰到死胡同就不回头，因此被称为“深搜”。
深度优先搜索详解
panpanpan17452的博客
10-10 4866
深度优先搜索详解
算法详解之深度优先搜索算法
热门推荐
LQ的博客
10-28 2万+
深度优先搜索算法
DFS深度优先搜索
咸鱼势力登场
06-28 9848
一、DFS的概念 {DFS的定义 DFS的搜索方式 DFS采用的数据结构 DFS的特点} 二、DFS的实战应用 {1.排列数字 2.n-皇后问题}
C#深度优先搜索算法
08-30
主要介绍了C#深度优先搜索算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++ 算法篇 深度优先搜索（DFS）
流年的博客
01-28 1万+
图的遍历 图的遍历为从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次的过程。 对于图的遍历，不想树那么简单，需要在遍历的过程中把访问过的顶点打上标记，以避免访问多次。具体办法是设置一个访问数组visited[n]，n是图中顶点的个数，初始值为0，访问后设置为1。 对于图的遍历来说，通常有两种遍历方案：深度优先遍历和广度优先遍历。 深度优先遍历 深度优先遍历（Depth_Fi...
基础-深度优先搜索（DFS）
Ice_teapoy的博客
02-19 1916
1 深度优先搜索（DFS） 1.1 定义 先说什么是搜索。搜索算法是利用计算机的高性能来有目的的穷举一个问题解空间的部分或所有的可能情况，从而求出问题的解的一种方法。在忽略效率的情况下，没有什么是搜索解决不了的（？ 深度优先搜索（DFS）是基于递归的搜索。 想象你在走迷宫： 1、 这个方向有路可走，我没走过 2、 往这个方向前进 3、 是死胡同（到达了已经走过的地方），往回走，回到上一个路口 4、 重复第一步，直到找着出口 通过这种方式，只要地点的数量是有限的，你就一定可以在有限的时间找到迷宫的出口（或者确
【Python搜索算法】深度优先搜索（DFS）算法原理详解与应用，示例+代码
qq_35831906的博客
10-16 1万+
深度优先搜索（DFS）是一种重要的图遍历算法，用于探索图中的节点和边。本节介绍DFS算法原理和DFS算法应用案例：解决路径查找问题，解决图的连通性问题：查找下图中的连通组件，拓扑排序，在树结构中进行深度遍历
深度优先搜索（DFS）
m0_68805093的博客
08-11 958
深度优先搜索（Depth-First Search，DFS）是一种常见的图遍历算法，用于在图或树等数据结构中探索所有可能的路径，以及查找特定目标（如寻找路径、判断连通性等）。DFS从一个起始顶点出发，沿着一条路径尽可能深入地访问顶点，直到不能继续为止，然后回溯到之前的顶点，继续尝试其他路径。这个过程通常使用递归来实现。在图的DFS中，我们需要记录已经访问过的顶点，以避免无限循环。从起始顶点开始，对于每个未访问的邻接顶点，我们递归地执行DFS。下图为一个示例图，我们将对这个图进行DFS遍历。
数据结构与算法(三) 深度优先搜索
半虹小站
11-05 2161
本篇文章首先来学习深度优先搜索算法（Depth-First-Search，DFS）
算法数据结构——图的遍历之深度优先搜索算法（Depth First Search）
白话机器学习
06-06 9049
深度优先搜索算法（Depth First Search）：英文缩写为 DFS。是一种用于搜索树或图的算法。所谓深度优先，就是说每次都尝试向更深的节点走。深度优先搜索采用了回溯思想，该算法沿着树的深度遍历树的节点，会尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。
DFS（深度优先搜索）详解（概念讲解，图片辅助，例题解释，剪枝技巧）
aliyonghang的博客
01-25 7063
深度优先搜索作为初学者遇到的第一个算法，给大家留下了许多“美好”的回忆。不说废话，先来看看百度百科是怎么说的。深度优先搜索是一种在开发爬虫早期使用较多的方法。它的目的是要达到被搜索结构的叶结点(即那些不包含任何超链的HTML文件在一个HTML文件中，当一个超链被选择后，被链接的HTML文件将执行深度优先搜索，即在搜索其余的超链结果之前必须先完整地搜索单独的一条链。深度优先搜索沿着HTML文件上的超链走到不能再深入为止，然后返回到某一个HTML文件，再继续选择该HTML文件中的其他超链。当不再有其他超链。
深度优先搜索算法（depth-first-search）
xiaoxi_hahaha的博客
07-24 2346
本文以迷宫的例子详细介绍了DFS算法的基本思想和实际应用。
深度优先搜索 matlab
最新发布
05-02
深度优先搜索（Depth First Search，DFS）是种常用的图遍历算法，用于遍历或搜索图或树的数据结构。在深度优先搜索中，从起始节点开始，沿着一条路径尽可能深入地探索，直到无法继续为止，然后回溯到前一个节点，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值