C语言实现图的广度优先搜索遍历算法

Posted 2023-04-16

非递归的...

参考技术A 先写个大题思路，楼主先自己想想，想不出来的话，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);


追问

同学，我急用的，两天后就不需要了...，谢啦...

追答

#include
#include
#include
#include

using std::queue;//队列懒得自己写了，C++之，楼主有兴趣可以自己实现

#define MN 10000
#define ME 100000
/*链式前向星*/
int n,e;//结点数，边数
int box[MN];
struct

int pre;//前向对应的edge数组下标
int to;//对应要去的结点
edge[ME];
int len;
void iniPreLinkList()

memset(box,-1,sizeof(box));
len=0;

void addDirectedEdge(int from,int to)

edge[len].to = to;
edge[len].pre = box[from];
box[from] = len;
len++;

void printList()

int address;
int i;
for(i=0;i%d",edge[address].to);

printf("\n");


/*链式前向星*/
int canVisit[MN];
void visit(int address)//访问结点，可根据情况，修改box结点域的结构

printf("访问结点%d\n",edge[address].to);

void bfs(int start)

memset(canVisit,1,sizeof(canVisit));
queue q;
q.push(start);
int cur;
int address;
printf("开始宽搜了哦~~~\n");
visit(start);
canVisit[start]=0;
while(!q.empty())

cur = q.front();
q.pop();
for(address=box[cur];address!=-1;address = edge[address].pre)

if(canVisit[edge[address].to])

visit(address);
canVisit[edge[address].to] = 0;//标记，访问过的不再访问
q.push(edge[address].to);//新访问的结束



printf("遍历完成\n");

int main()

int i;
int from,to;
while(~scanf("%d%d",&n,&e))//输入结点数，边数

iniPreLinkList();
for(i=0;i<e;i++)

scanf("%d%d",&from,&to);//输入边
addDirectedEdge(from,to);

printf("刚才构造的邻接链表为：\n");
printList();
printf("\n");
bfs(0);

return 0;

/*
4 4
0 1
1 2
0 2
1 3
*/

本回答被提问者采纳 参考技术B ...

Java实现图的深度和广度优先遍历算法

概述：

  近期要学习写网络爬虫。所以把图的深度和广度搜索都再温习一下。

图结构展示：

实现过程：

首先，我们来看看图结构在代码中的实现。有三块逻辑：

1.图中的节点：

public class GraphNode {

	public List<GraphEdge> edgeList = null;
	
	private String label = "";
	
	public GraphNode(String label) {
		this.label = label;
		if (edgeList == null) {
			edgeList = new ArrayList<GraphEdge>();
		}
	}
	
	/**
	 * 给当前节点加入一条边
	 * GraphNode
	 * @param edge
	 * 			加入的边
	 */
	public void addEdgeList(GraphEdge edge) {
		edgeList.add(edge);
	}
	
	public String getLabel() {
		return label;
	}
}

 

2.图中的边：

 

public class GraphEdge {

	private GraphNode nodeLeft;
	
	private GraphNode nodeRight;

	/**
	 * @param nodeLeft
	 * 			边的左端
	 * @param nodeRight
	 * 			边的右端
	 */
	public GraphEdge(GraphNode nodeLeft, GraphNode nodeRight) {
		this.nodeLeft = nodeLeft;
		this.nodeRight = nodeRight;
	}

	public GraphNode getNodeLeft() {
		return nodeLeft;
	}

	public GraphNode getNodeRight() {
		return nodeRight;
	}
	
}

 

3.把节点和边组合成一个图结构：

 

public class MyGraph {

	private List<GraphNode> nodes = null;
	
	public void initGraph(int n) {
		if (nodes == null) {
			nodes = new ArrayList<GraphNode>();
		}
		
		GraphNode node = null;
		for (int i = 0; i < n; i++) {
			node = new GraphNode(String.valueOf(i));
			nodes.add(node);
		}
	}
	
	public void initGraph(int n, boolean b) {
		initGraph(n);
		GraphEdge edge01 = new GraphEdge(nodes.get(0), nodes.get(1));
		GraphEdge edge02 = new GraphEdge(nodes.get(0), nodes.get(2));
		GraphEdge edge13 = new GraphEdge(nodes.get(1), nodes.get(3));
		GraphEdge edge14 = new GraphEdge(nodes.get(1), nodes.get(4));
		GraphEdge edge25 = new GraphEdge(nodes.get(2), nodes.get(5));
		GraphEdge edge26 = new GraphEdge(nodes.get(2), nodes.get(6));
		GraphEdge edge37 = new GraphEdge(nodes.get(3), nodes.get(7));
		GraphEdge edge47 = new GraphEdge(nodes.get(4), nodes.get(7));
		GraphEdge edge56 = new GraphEdge(nodes.get(5), nodes.get(6));
		
		
		nodes.get(0).addEdgeList(edge01);
		nodes.get(0).addEdgeList(edge02);
		nodes.get(1).addEdgeList(edge13);
		nodes.get(1).addEdgeList(edge14);
		nodes.get(2).addEdgeList(edge25);
		nodes.get(2).addEdgeList(edge26);
		nodes.get(3).addEdgeList(edge37);
		nodes.get(4).addEdgeList(edge47);
		nodes.get(5).addEdgeList(edge56);
	}
	
	public void initGraph() {
		initGraph(8, false);
	}
	
	public List<GraphNode> getGraphNodes() {
		return nodes;
	}
}

 
有了图的结构，我们就能够进行一些实际的操作了。

深度优先搜索：

 

public class DFSearch {
	
	/**
	 * 深度遍历
	 * DFSearch
	 * @param node
	 * 			当前节点
	 * @param visited
	 * 			被訪问过的节点列表
	 */
	public void searchTraversing(GraphNode node, List<GraphNode> visited) {
		// 推断是否遍历过
		if (visited.contains(node)) {
			return;
		}
		
		visited.add(node);
		System.out.println("节点：" + node.getLabel());
		for (int i = 0; i < node.edgeList.size(); i++) {
			searchTraversing(node.edgeList.get(i).getNodeRight(), visited);
		}
	}
}

 

广度优先搜索：

 

public class BFSearch {
	
	/**
	 * 广度优先搜索
	 * BFSearch
	 * @param node
	 * 			搜索的入口节点
	 */
	public void searchTraversing(GraphNode node) {
		List<GraphNode> visited = new ArrayList<GraphNode>(); // 已经被訪问过的元素
		Queue<GraphNode> q = new LinkedList<GraphNode>(); // 用队列存放依次要遍历的元素
		q.offer(node);
		
		while (!q.isEmpty()) {
			GraphNode currNode = q.poll();
			if (!visited.contains(currNode)) {
				visited.add(currNode);
				System.out.println("节点：" + currNode.getLabel());
				for (int i = 0; i < currNode.edgeList.size(); i++) {
					q.offer(currNode.edgeList.get(i).getNodeRight());
				}
			}
		}
	}
}

 

执行结果：

源代码下载：

http://download.csdn.net/detail/u013761665/8968443