广度优先遍历

额。。一到五个结点就报错。。。

typedef struct
{
    int **table;
    int num;
}Graph; 

typedef struct Queue
{
    int data;
    struct Queue *next;
}Queue;

void createTable(Graph *graph);
void des(Graph *graph);
void travel(Graph *graph, int first);
void init(Queue *q);
void enQueue(Queue *q, int num);
void deQueue(Queue *q, int *num);
int emptyQueue(Queue *q); 

int main(int argc, char *argv[])
{
    Graph graph;

    printf("请输入结点数:");
    scanf("%d", &(graph.num));
    createTable(&graph);

    travel(&graph, 2); 

    des(&graph);
    return 0;
}

void travel(Graph *graph, int first)
{
    first -= 1;
    int num = graph->num;
    int **table = graph->table;
    Queue q;
    int i, cur;
    int visit[num];

    for(i=0;i<num;i++)
    {
        visit[i] = 0;
     } 

    init(&q);
    enQueue(&q, first);

    while(!emptyQueue(&q))
    {
        deQueue(&q, &cur);
        printf("%d ", cur+1);
        visit[cur] = 1;

        for(i=0; i<num; i++)
        {
            if(table[cur][i] && (!visit[i]))
            {
                visit[i] = 1;
                enQueue(&q, i);
            }
        }
    }

}

void init(Queue *q)
{
    q->data = 0;
    q->next = NULL;
}

void enQueue(Queue *q, int num)
{
    Queue *p = q;
    while(p->next)
    {
        p = p->next;
    }
    p->next = (Queue *)malloc(sizeof(Queue));
    p = p->next;
    p->next = NULL;
    p->data = num;
}

void deQueue(Queue *q, int *num)
{
    Queue *p = q;
    Queue *temp;

    if(emptyQueue(q))
    {
        return;
    }

    temp = p->next->next;
    *num = p->next->data;

    free(p->next);
    p->next = temp;
}

int emptyQueue(Queue *q)
{
    if(q->next)
    {
        return 0;
    }else {
        return 1;
    }
}

void createTable(Graph *graph)
{
    int num = graph->num;
    int **table;
    int i, j, temp;

    table = (int **)malloc(sizeof(int)*num);
    for(i=0; i<num; i++)
    {
        table[i] = (int *)malloc(sizeof(int)*num);
    }

    for(i=0; i<num; i++)
    {
        printf("第 %d 行:", i+1);
        for(j=0;j<num;j++)
        {
            scanf("%d", &temp);
            if(temp == ‘ ‘)
            {
                j -= 1;
            }else {
                (table)[i][j] = temp;
            }
        }
        getchar();
    }

    graph->table = table; 

}

void des(Graph *graph)
{
    int num = graph->num;
    int i, j;

    printf("\n");
    for(i=0; i<num; i++)
    {
        for(j=0;j<num;j++)
        {
            printf("%d ", (graph->table)[i][j]);
        }
        printf("\n");
        //free((graph->table)[i]);
    }
    //free(graph->table);
    graph->num = 0;
}
时间: 2024-08-04 03:39:14

广度优先遍历的相关文章

浅谈数据结构之图的邻接表深度和广度优先遍历(九)

邻接矩阵是一种不错的图存储结构,但是我们发现,对于边数相对较少的图,这种结构是存在对存储空间的极大浪费的.我们知道,顺序存储结构存在预先分配内存可能造成空间浪费的问题,于是引出了链式存储的结构.同样的,我们也可以考虑对边或弧使用链式存储的方式来避免空间浪费的问题.因此,对于图的存储结构,我们同样引入了一种数组与链表相组合的存储方法,我们一般称之为邻接表. 邻接表的处理方法是这样的:(1).图中顶点用一个一维数组存储,当然,顶点也可以用单链表来存储,不过数组可以较容易的读取顶点的信息,更加方便:另

Leetcode - 广度优先遍历专题

> 基础 1. 广度遍历优先是从给定的root节点开始,逐层次的向下访问各个节点: 2. 实现的方式是通过队列的先进先出,将从root节点开始的左孩子和右孩子压入到队列中,并顺序取出: 3. 由于是用队列实现,因此不存在用递归实现的方式. 下面是基本的广度遍历优先算法: 1 def breadthFirstSearch(root): 2 queue = [] 3 queue.append(root) 4 while queue: 5 node = queue[0] 6 queue.pop(0)

树的深度优先遍历和广度优先遍历

1 import java.util.ArrayDeque; 2 3 public class BinaryTree { 4 static class TreeNode{ 5 int value; 6 TreeNode left; 7 TreeNode right; 8 9 public TreeNode(int value){ 10 this.value=value; 11 } 12 } 13 14 TreeNode root; 15 16 public BinaryTree(int[] ar

二叉树 广度优先遍历

/** * 广度优先遍历 * **/ public void BreadthFirstTreeWalk(BSTreeNode<T> root, Action<BSTreeNode<T>> func) { if (root == null) { return; } List<BSTreeNode<T>> processQueue = new List<BSTreeNode<T>>(); processQueue.Add(ro

图---广度优先遍历

1.解决问题:判断一幅图中 从顶点S到顶点V之间是否有一条路径---Dijkstar算法的基础(计算出S--V点中最短路径) 1.使用队列(FIFO)先进先出原则 存储与顶点S相距 N条边的点,直到遍历到V点上  不同于深度优先遍历 不需要进行递归 因此 BFS无法判断图中是否有环的 判断出一个有向图是否有环的是:a.最短路径有向图最短路径Dijkstra不一定能够判断有环,除非Visted数字记录0(false),1(已经访问)2(再一次重复访问): b.括扑排序:通过入度0之后记录顶点数与原

二叉树遍历(前序、中序、后序、层次、深度优先、广度优先遍历)

二叉树是一种非常重要的数据结构,很多其它数据结构都是基于二叉树的基础演变而来的.对于二叉树,有深度遍历和广度遍历,深度遍历有前序.中序以及后序三种遍历方法,广度遍历即我们平常所说的层次遍历.因为树的定义本身就是递归定义,因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁,而对于广度遍历来说,需要其他数据结构的支撑,比如堆了.所以,对于一段代码来说,可读性有时候要比代码本身的效率要重要的多. 四种主要的遍历思想为: 前序遍历:根结点 ---> 左子树 ---> 右子树 中序遍历:左子

如何实现广度优先遍历(BFS)

BFS过程: 一:访问顶点V,并标记V为已经访问 二:顶点V入队列 三:如果队列非空,进行执行,否则算法结束 四:出队列取得对头顶点u,如果顶点未被访问,就访问该顶点,并标记该顶点为已经访问 五:查找u的第一个邻接节点w 六:如果w不存在,则转到步骤三,否则循环执行 a. 如果w没有被访问过,则先把w入队列 b.查找顶点u的下一个邻接节点,记为w,并转到步骤六 上图使用BFS访问顺序为: A BEDC 队列的变化过程如下: A B BE ED D C 代码如下: #include<iostrea

Dungeon Master UVA 532 (三维空间的广度优先遍历)

说说: 其实这道题就是一道广度优先遍历求最短路径的简单题目.但是可能今晚状态不太好,开始一直想当然地就按深度优先遍历去写了.然后测试数据又刚好能通过,结果就特别地纠结.不过总的来说,这道题是非常简单的.至于代码的话,后来写得烦起来了,可能看起来有点凌乱QAQ 源代码: #include <stdio.h> #include <string.h> #define MAX 30+5 typedef struct{ int x; int y; int z; int dis; }NODE;

树的深度优先与广度优先遍历

简述树的深度优先及广度优先遍历算法,并说明非递归实现. 原题出自百度的笔试: 当时我看到这个题目的时候,已经完全记不得非递归算法该怎么实现了,后来查阅了一下,要用到两个辅助的数据结构: 深度优先遍历--->栈: 广度优先遍历--->队列: 这里以二叉树为例来实现. import java.util.ArrayDeque; public class BinaryTree { static class TreeNode{ int value; TreeNode left; TreeNode rig

二叉树的深度优先遍历和广度优先遍历

1. 二叉树的深度优先遍历,使用栈Stack, DFS(Depth First Search) function DFS(root){ var stack = []; stack.push(root); var node = null; while(stack.length){ node = stack.pop(); //visit node.data; if(node.right){ stack.push(node.right); } if(node.left){ stack.push(nod