c廣度優先演算法
A. 深度優先和廣度優先 的區別 ，用法。
1、主體區別
深度優先搜索是一種在開發爬蟲早期使用較多的方法。它的目的是要達到被搜索結構的葉結點(即那些不包含任何超鏈的HTML文件)。
寬度優先搜索演算法（又稱廣度優先搜索）是最簡便的圖的搜索演算法之一，這一演算法也是很多重要的圖的演算法的原型。
2、演算法區別
深度優先搜索是每次從棧中彈出一個元素，搜索所有在它下一級的元素，把這些元素壓入棧中。並把這個元素記為它下一級元素的前驅，找到所要找的元素時結束程序。
廣度優先搜索是每次從隊列的頭部取出一個元素，查看這個元素所有的下一級元素，把它們放到隊列的末尾。並把這個元素記為它下一級元素的前驅，找到所要找的元素時結束程序。
3、用法
廣度優先屬於一種盲目搜尋法，目的是系統地展開並檢查圖中的所有節點，以找尋結果。換句話說，它並不考慮結果的可能位置，徹底地搜索整張圖，直到找到結果為止。
深度優先即在搜索其餘的超鏈結果之前必須先完整地搜索單獨的一條鏈。深度優先搜索沿著HTML文件上的超鏈走到不能再深入為止，然後返回到某一個HTML文件，再繼續選擇該HTML文件中的其他超鏈。
(1)c廣度優先演算法擴展閱讀：
實際應用
BFS在求解最短路徑或者最短步數上有很多的應用，應用最多的是在走迷宮上，單獨寫代碼有點泛化，取來自九度1335闖迷宮一例說明，並給出C++/Java的具體實現。
在一個n*n的矩陣里走，從原點（0,0）開始走到終點（n-1,n-1），只能上下左右4個方向走，只能在給定的矩陣里走，求最短步數。n*n是01矩陣，0代表該格子沒有障礙，為1表示有障礙物。
int mazeArr[maxn][maxn]; //表示的是01矩陣int stepArr = {{-1,0},{1,0},{0,-1},{0,1}}; //表示上下左右4個方向，int visit[maxn][maxn]; //表示該點是否被訪問過，防止回溯，回溯很耗時。核心代碼。基本上所有的BFS問題都可以使用類似的代碼來解決。
B. c語言廣度優先演算法
既然b[i]記錄的是前驅城市。
那也就是通過i的前一個城市存在b[i]中，能保證從A到H是最短的。
C. c語言關於圖的廣度優先遍歷
深度優先是沿著一條路走到底，走不通了或到頭了，再回溯，再搜索。而廣搜是先搜離得最近的，再慢慢搜索遠的，隊列就是按順序存，所以開頭存的近的，末尾存遠的，說白了隊列就是從近到遠保存數據的，說的不好，希望對你會點幫助。
D. 關於廣度優先搜索演算法
廣度優先搜索演算法，是按層遍歷各個結點，以求出最短或最優的解，
常用於計算路徑的最短距離，和最佳通路。
例如：迷宮的最短路徑計算，推箱子的移動最小步數等小游戲，都是按廣度搜索來進行的。
這個演算法是教程中很經典的，有很多例子和代碼。你可以好好研究！
如下是一段迷宮的最佳路徑求解演算法。
#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
const int dx[4]={-1,0,1,0};
const int dy[4]={0,1,0,-1};
int maze[5][5],prev[5][5];
int que[32];
int qn;
void print(int x,int y)
{
if(prev[x][y]!=-2)
{
print(prev[x][y]>>3,prev[x][y]&7);
}
printf("(%d, %d)\n",x,y);
}
int main()
{
int i,j,cx,cy,nx,ny;
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
scanf("%d",&maze[i][j]);
}
}
memset(prev,-1,sizeof(prev));
prev[0][0]=-2;
que[0]=0;
qn=1;
for(i=0;i<qn;i++)
{
cx=que[i]>>3;
cy=que[i]&7;
for(j=0;j<4;j++)
{
nx=cx+dx[j];
ny=cy+dy[j];
if((nx>=0)&&(nx<5)&&(ny>=0)&&(ny<5)&&(maze[nx][ny]==0)&&(prev[nx][ny]==-1))
{
prev[nx][ny]=(cx<<3)|cy;
que[qn++]=(nx<<3)|ny;
if((nx==4)&&(ny==4))
{
print(nx,ny);
return 0;
}
}
}
}
return 0;
}
E. 廣度優先演算法
廣度優先演算法（Breadth-First Search），同廣度優先搜索，又稱作寬度優先搜索，或橫向優先搜索，簡稱BFS，是一種圖形搜索演演算法。簡單的說，BFS是從根節點開始，沿著樹的寬度遍歷樹的節點，如果發現目標，則演算終止。廣度優先搜索的實現一般採用open-closed表。
F. 廣度優先遍歷是什麼
1.廣度優先遍歷的思想廣度優先遍歷類似樹的按層次遍歷。設初始狀態時圖中的所有頂點未被訪問，則演算法思想為：首先訪問圖中某指定的起始頂點v，並將其標記為已訪問過，然後由v出發依次訪問v的各個未被訪問的鄰接點v1，v2，…，vk；並將其均標識為已訪問過，再分別從v1，v2，…，vk出發依次訪問它們未被訪問的鄰接點，並使「先被訪問頂點的鄰接點」先於「後被訪問頂點的鄰接點」被訪問。直至圖中所有與頂點v路徑相通的頂點都被訪問到。
若G是連通圖，則遍歷完成；否則，在圖G中另選一個尚未訪問的頂點作為新源點繼續上述搜索過程，直至圖G中所有頂點均被訪問為止。
2.廣度優先遍歷示例例如，對圖7－18（a）所示的圖G，假設指定從頂點v1開始進行廣度優先遍歷，首先訪問v1，因與v1相鄰並且未被訪問過的頂點有v2和v6，則訪問v2和v6，然後訪問與v2相鄰並未訪問的鄰接點v2，v7，再訪問與v6相鄰並且未被訪問過的鄰接點v5，按這樣的次序依次訪問與v2相鄰並且未被訪問過的鄰接點v4，v8，與v7相鄰並且未被訪問過的鄰接點v9，此時，與v5，v4，v8，v9相鄰並且未被訪問過的鄰接點沒有了，即圖G中的所有頂點訪問完，其遍歷序列為：v1－＞v2－＞v6－＞v2－＞v7－＞v5－＞v4－＞v8－＞v9。這種順序不是唯一的，如果從v1出發後，相鄰的多個頂點優先選擇序號大的頂點訪問，其遍歷序列為：v1－＞v6－＞v2－＞v5－＞v7－＞v2－＞v4－＞v9－＞v8。同理，圖7－18（b）是假設從v1開始，相鄰的多個頂點優先選擇序號小的頂點訪問，其遍歷序列為：v1－＞v2－＞v2－＞v4－＞v5－＞v6－＞v7－＞v8；相鄰的多個頂點優先選擇序號大的頂點訪問，其遍歷序列為：v1－＞v2－＞v2－＞v7－＞v6－＞v5－＞v4－＞v8。圖7－18（c）假設從a開始，相鄰的多個頂點優先選擇ASCII碼小的頂點訪問，其遍歷序列為：a－＞b－＞d－＞e－＞f－＞c－＞g；相鄰的多個頂點優先選擇ASCII碼大的頂點訪問，其遍歷序列為：a－＞f－＞e－＞d－＞b－＞g－＞c。
2.廣度優先遍歷的演算法在廣度優先遍歷中，要求先被訪問的頂點其鄰接點也被優先訪問，因此，必須對每個頂點的訪問順序進行記錄，以便後面按此順序訪問各頂點的鄰接點。應利用一個隊列結構記錄頂點的訪問順序，將訪問的每個頂點入隊，然後再依次出隊。
在廣度優先遍歷過程中，為了避免重復訪問某個頂點，也需要創建一個一維數組visited［n］（n是圖中頂點的數目），用來記錄每個頂點是否已被訪問過。
G. 求一個廣度優先演算法的實例及其C語言程序（L-dequeue）
#include <stdio.h>
#define max 100
typedef struct anode
{
int adjvex; //邊的終點位置
struct anode *nextarc;
}arcnode;
typedef struct node
{
int data;
arcnode *firstout;
}vnode;
typedef struct
{
vnode adjlist[max];
int n;
int e;
}Agraph;
static int visit[max];
//深度遍歷
void DFS(Agraph &G,int v) //v為初始頂點編號
{
int k;
arcnode *p;
for(k=0;k<G.n;k++)
visit[k]=0;
printf("%d ",v);
p=G.adjlist[v].firstout;
while(p)
{
if(!visit[p->adjvex])
DFS(G,p->adjvex);
p=p->nextarc;
}
}
void BFS(Agraph &G,int v)
{
arcnode *p;
int q[max];
int front=0;
int rear=0;
int w,i;
for(i=0;i<G.n;i++)
visit[i]=0;
printf("%d ",v);
visit[v]=1;
rear=(rear+1)%max;
q[rear]=v;
while(front!=rear)
{
front=(front+1)%max;
w=q[front];
p=G.adjlist[w].firstout;
while(p)
{
if(!visit[p->adjvex])
{
printf("%d ",p->adjvex);
visit[p->adjvex]=1;
rear=(rear+1)%max;
q[rear]=p->adjvex;
}
p=p->nextarc;
}
printf("\n");
}
}
//層序遍歷二叉樹
struct btnode
{
int data;
btnode *lchild,*rchild;
};
void level(struct btnode *bt)
{
if(!bt)
return;
btnode *q[max];
int front,rear;
front=0;
rear=0;
printf("%d ",bt->data);
rear=(rear+1)%max;
q[rear]=bt;
while(front!=rear)
{
front=(front+1)%max;
bt=q[front];
if(bt->lchild)
{
printf("%d ",bt->lchild->data);
rear=(rear+1)%max;
q[rear]=bt->lchild;
}
if(bt->rchild)
{
printf("%d ",bt->rchild->data);
rear=(rear+1)%max;
q[rear]=bt->rchild;
}
}
}
void DFS1(Agraph &G,int v)
{
arcnode *p;
printf("%d ",v);
visit[v]=1;
p=G.adjlist[v].firstout;
while(p)
{
if(!visit[p->adjvex])
{
DFS1(G,p->adjvex);
}
p=p->nextarc;
}
}
void level1(struct btnode *bt)
{
if(!bt)
return;
printf("%d ",bt->data);
struct btnode *q[max];
int front=0;
int rear=0;
rear=(rear+1)%max;
q[rear]=bt;
while(front!=rear)
{
front=(front+1)%max;
bt=q[front];
if(bt->lchild)
{
printf("%d ",bt->lchild->data);
rear=(rear+1)%max;
q[rear]=bt->lchild;
}
if(bt->rchild)
{
printf("%d ",bt->rchild->data);
rear=(rear+1)%max;
q[rear]=bt->rchild;
}
}
}
void BFS1(Agraph &G,int v)
{
int q[max];
int front=0;
int rear=0;
int i;
for(i=0;i<G.n;i++)
visit[i]=0;
printf("%d ",v);
visit[v]=1;
rear=(rear+1)%max;
q[rear]=v;
arcnode *p;
while(front!=rear)
{
front=(front+1)%max;
i=q[front];
p=G.adjlist[i].firstout;
while(p)
{
if(!visit[p->adjvex])
{
printf("%d ",p->adjvex);
visit[p->adjvex]=1;
rear=(rear+1)%max;
q[rear]=p->adjvex;
}
p=p->nextarc;
}
}
}
H. c語言 在用廣度優先演算法求最短路徑時候，怎麼樣能記錄它的路徑
路徑
template<class Type>
void Dijkstra(int n, int v, Type dist[], int prev[], Type **c) {
//單源最短路徑問題的 Dijkstra 演算法
bool s[maxint];
for (int i = 1; i <= n; i++) {
dist[i] = c[v][i];
s[i] = false;
if (dist[i] == maxint) prev[i] = 0;
else prev[i] = v;
}
dist[v] = 0; s[v] = true;
for (int i = 1; i < n; i++) {
int temp = maxint;
int u = v;
for (int j = 1; j <= n; j++)
if (!s[j] && dist[j] < temp) {
u = j;
temp = dist[j];
}
s[u] = true;
for (int j = 1; j <= n; j++)
if (!s[j] && c[i][j] < maxint) {
Type newdist = dist[u] + c[u][j];
if (newdist < dist[j]) {
dist[j] = newint;
prev[j] = u;
}
}
}
}
另外,站長團上有產品團購,便宜有保證
I. C語言實現圖的廣度優先搜索遍歷演算法
先寫個大題思路，樓主先自己想想，想不出來的話，2天後給代碼。
queue<node> q;
q.push(start);
bool canVisit[][];
node cur;
while(!q.empty()){
cur = q.top();
q.pop();
foreach(node is connected by cur){
if(canVisit[node.x][node.y])
{
printf("訪問結點(%d,%d)",node.x,node.y);
canVisit[node.x][node.y]=false;
q.push(node);
}
}
}
J. 廣度優先搜索C語言演算法
它沒有固定的寫法， 但是大框都差不多， 一定要使用隊列， 因為隊列的存在可以維護程序按照廣度優先的方式進行搜索。即層次遍歷
可以給你一份我作過的一個題的代碼，大體上就是這個樣子
/****************************************************\
*
* Title : Rescue
* From : HDU 1242
* AC Time : 2012.01.12
* Type : 廣度優先搜索求最短步數
* Method :從目標結點向回搜索，初始結點有多個
*
\****************************************************/
#include <stdio.h>
#include <string.h>
#define DATASIZE 201
#define QUEUESIZE 65536
typedef struct
{
int x,y;
}CPOINT;
int bfs(char map[][DATASIZE], int n, int m, CPOINT cpa);
int direction[][2] = {{1,0},{-1,0},{0,1},{0,-1}};
int main(void)
{
int m,n,i,j,res;
CPOINT cpa;
char map[DATASIZE][DATASIZE];
freopen("c:\\in.data","r",stdin);
while(scanf("%d%d%*c",&n,&m) != EOF) {
for(i = 0 ; i < n ; i++) {
gets(map[i]);
for(j = 0 ; j < m ; j++) {
if(map[i][j] == 'a') {
cpa.x = i;
cpa.y = j;
}
}
}
res = bfs(map, n, m, cpa);
if(res) {
printf("%d\n",res);
} else {
printf("Poor ANGEL has to stay in the prison all his life.\n");
}
}
return 0;
}
int bfs(char map[][DATASIZE], int n, int m, CPOINT cpa)
{
CPOINT q[QUEUESIZE],u,np;
int vis[DATASIZE][DATASIZE],step[DATASIZE][DATASIZE],i,front,rear,res;
memset(q, 0, sizeof(q));
memset(vis, 0, sizeof(vis));
memset(step, 0, sizeof(step));
front = rear = res = 0;
q[rear++] = cpa;
vis[cpa.x][cpa.y] = 1;
step[cpa.x][cpa.y] = 0;
while(front <= rear) {
u = q[front++];
if(map[u.x][u.y] == 'r') {
res = step[u.x][u.y];
break;
}
for(i = 0 ; i < 4; i++) {
np.x = u.x + direction[i][0];
np.y = u.y + direction[i][1];
if(np.x >= 0 && np.x < n && np.y >= 0 && np.y < m && !vis[np.x][np.y] && map[np.x][np.y] != '#' ) {
vis[np.x][np.y] = 1;
q[rear++] = np;
step[np.x][np.y] = step[u.x][u.y] + 1;
if(map[np.x][np.y] == 'x') {
++step[np.x][np.y];
}
}
}
}
return res;
}