深度优先搜索和广度优先搜索实现

最新推荐文章于 2022-08-17 17:07:55 发布

xiaowenmu1

最新推荐文章于 2022-08-17 17:07:55 发布

阅读量141

点赞数

CC 4.0 BY-SA版权

分类专栏：算法

本文链接：https://blog.youkuaiyun.com/xiaowenmu1/article/details/99562974

算法专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍了广度优先搜索(BFS)和深度优先搜索(DFS)的非递归实现方法，并通过C++代码示例展示了如何在图数据结构中应用这两种算法。作者在面试遭遇难题后，重新梳理并记录了算法的具体步骤，旨在帮助读者深入理解并掌握这两项基本搜索技术。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

面试被问到广度优先搜索和深度优先搜索的非递归实现，脑袋瞬间空白.....，之前看过的都瞬间忘记了，还是没有多写所以记得不是很牢靠，所以在这里再写一遍。

//dfs递归和非递归实现

#include<stdlib.h>
#include<iostream>
#include<vector>
#include<stack>

using namespace std;
struct Node {
	Node(int v):val(v),gone(false){}
	vector<Node *> neighbors;
	bool gone;
	int val;
};


void dfs(Node *root,vector<int> &result) {
    if(root == nullptr)
        return;
	stack<Node *> save;
	save.push(root);
	root->gone = true;
	result.push_back(root->val);
	while (!save.empty()) {
		Node *cur = save.top();
		int len = (cur->neighbors).size();
		int i = 0;
		while (i < len && (cur->neighbors)[i]->gone == true) ++i;
		if (i == len)
			save.pop();
		else {
			save.push((cur->neighbors)[i]);
			(cur->neighbors)[i]->gone = true;
			result.push_back((cur->neighbors)[i]->val);
		}
	}
	return;

}


void dfsRecursion(Node *root, vector<int> &result) {
	if (root == nullptr)
		return;
	int len = (root->neighbors).size();
	result.push_back(root->val);
	root->gone = true;
	for (int i = 0; i < len; ++i) {
		if ((root->neighbors)[i]->gone == true)
			continue;
		dfsRecursion((root->neighbors)[i], result);
	}
	return;
}

void bfs(Node *root, vector<int> &result) {
	if (root == nullptr)
		return;
	queue<Node *> save;
	save.push(root);
	root->gone = true;
	result.push_back(root->val);
	while (!save.empty()) {
		int size = save.size();
		for (int j = 0; j < size; ++j) {
			Node *cur = save.front();
			save.pop();
			int len = (cur->neighbors).size();
			for (int i = 0; i < len; ++i) {
				if ((cur->neighbors)[i]->gone == true)
					continue;
				result.push_back((cur->neighbors)[i]->val);
				(cur->neighbors)[i]->gone = true;
				save.push((cur->neighbors)[i]);
			}
		}
	}
	return;
}



int main() {

	Node *node1 = new Node(1);
	Node *node2 = new Node(2);
	Node *node3 = new Node(3);
	Node *node4 = new Node(4);
	Node *node5 = new Node(5);
	Node *node6 = new Node(6);
	Node *node7 = new Node(7);
	Node *node8 = new Node(8);
	Node *node9 = new Node(9);

	(node1->neighbors).push_back(node2);
	(node1->neighbors).push_back(node3);

	(node2->neighbors).push_back(node1);
	(node2->neighbors).push_back(node4);
	(node2->neighbors).push_back(node5);


	(node3->neighbors).push_back(node1); 
	(node3->neighbors).push_back(node8);
	(node3->neighbors).push_back(node7);

	(node4->neighbors).push_back(node2);
	(node4->neighbors).push_back(node6);

	(node5->neighbors).push_back(node2);
	(node5->neighbors).push_back(node6);

	(node6->neighbors).push_back(node4);
	(node6->neighbors).push_back(node5);
	(node6->neighbors).push_back(node9);

	(node7->neighbors).push_back(node3);
	(node7->neighbors).push_back(node9);

	(node8->neighbors).push_back(node3);
	(node8->neighbors).push_back(node9);

	(node9->neighbors).push_back(node6);
	(node9->neighbors).push_back(node7);
	(node9->neighbors).push_back(node8);

	vector<int> result;
	dfs(node1, result);
	for (auto s : result) {
		cout << s << endl;
	}
	
    vector<int> result1;
	dfsRecursion(node1, result1);
	for (auto s : result1) {
		cout << s << endl;
	}

    vector<int> result2;
	bfs(node1, result2);
	for (auto s : result2) {
		cout << s << endl;
	}
    

	return 0;
}

输出为：
dfs:1 2 4 6 5 9 7 3 8
dfsRecursion:1 2 4 6 5 9 7 3 8
bfs:1 2 3 4 5 8 7 6 9