BFS，DFS程序（c++）

最新推荐文章于 2025-04-05 12:31:15 发布

原创最新推荐文章于 2025-04-05 12:31:15 发布 · 309 阅读

0 ·

CC 4.0 BY-SA版权

本文深入探讨了广度优先搜索(BFS)和深度优先搜索(DFS)算法的应用，包括层序遍历、无权最短路径求解、图中无闭环节点查找等核心问题。通过具体实例和代码解析，帮助读者理解这两种算法的工作原理和实现细节。

一个报错：缺少非空判断，或者你写错了对空指针操作了。如：if(!p)...//空指针操作了姐们

leetcode报错：member access within null pointer of type 'struct ListNode'

一维指针可以指向二维数组

int *p;
int a[2][2];
p=&a[1][1];
or
*p=a[1][1];

queue&vector

queue
q.push()  //进
q.pop()
vector
v.push_back()
v.pop_back()

BFS

遍历

BFS遍历->层序遍历->无权最短路径 https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/bfs-de-shi-yong-chang-jing-zong-jie-ceng-xu-bian-l/详解

层序遍历：层序遍历扫描完一行后，下一行从上一行第一个开始寻找，需要添加队列辅助。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 利用d
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vec;
        vector<int> b;
        queue<TreeNode *> q;
        int i,cnt,zov=1;
        TreeNode *t=root;
        if(!root)return vec;
        q.push(root);
        t=root;
        while(!q.empty())  //非NULL
        {
            for(i=0;i<zov;i++)  //每一层
            {
                t=q.front();
                b.push_back(t->val);
                q.pop();
                if(t->left)  //非NULL
                {
                    q.push(t->left);
                    cnt++;
                }
                if(t->right)
                {
                    q.push(t->right);
                    cnt++;
                }
            }
            vec.push_back(b);
            b.clear();
            zov=cnt;   //cnt记录每层非NULL的节点数
            cnt=0;
        }
        return vec;
    }
};

无权网络BFS遍历

void BFS_shortest()
{
 	int i,j,cnt=1,t,zoc=2;
 	queue<int>q;
 	for(i=0;i<N;i++)
 		for(j=0;j<N;j++)
 		{
 			a[i][j]=0;
		}
	a[2][2]=cnt;
	q.push(2);
	q.push(2);
	while(!q.empty())
	{
		cnt++;
		for(t=0;t<zoc/2;t++)
		{
			i=q.front();
			q.pop();
			j=q.front();
			q.pop();
			if(i+1<N&&a[i+1][j]==0)
			{
				a[i+1][j]=cnt;
				q.push(i+1);
				q.push(j);
			}
			if(i>0&&a[i-1][j]==0)
			{
				a[i-1][j]=cnt;
				q.push(i-1);
				q.push(j);
			}
			if(j+1<N&&a[i][j+1]==0)
			{
				a[i][j+1]=cnt;
				q.push(i);
				q.push(j+1);
			}
			if(j>0&&a[i][j-1]==0)
			{
				a[i][j-1]=cnt;
				q.push(i);
				q.push(j-1);
			}
		}	
		zoc=q.size();
	}
}
int main()

多启动BFS

leetcode1162地图分析问题

class Solution {
public:
    int maxDistance(vector<vector<int>>& grid) {
        int N=grid.size();
        int i,j,cnt=1,t;  //cnt初始1下列代表距离是2的实际距离为1，和land是1冲突，下面cnt掌握好
        do
        {
            t=0;               
            for(i=0;i<N;i++)
                for(j=0;j<N;j++)
                {
                    if(grid[i][j]==cnt)  //检测到距离为n的点
                    {
                        cout<<cnt<<':';
                        if(i+1<N&&grid[i+1][j]==0)
                        {
                            grid[i+1][j]=cnt+1;
                            t++;
                            cout<<'1';
                        }
                        if(i>0&&grid[i-1][j]==0)
                        {
                            grid[i-1][j]=cnt+1;
                            t++;
                            cout<<'2';
                        }
                        if(j+1<N&&grid[i][j+1]==0)
                        {
                            grid[i][j+1]=cnt+1;
                            t++;
                            cout<<'3';
                        }
                        if(j>0&&grid[i][j-1]==0)
                        {
                            grid[i][j-1]=cnt+1;
                            t++;
                        }
                        cout<<endl;
                     }
                }
            cnt++;
        }while(t);
        if(cnt==2)return -1;
        return cnt-2;
    }
};

DFS

第802题，找图中没有闭环的节点，这题，让我深刻体会到&传递的速度，前三次都是形参漏了&，导致一直超时

/*
找没有环的节点，采用深度优先搜索
//形参传递vector时漏了个&，一直超出时间限制，&确实快！
*/
class Solution {
public:
    vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
        int len,j=0,i=0;
        len=graph.size();
        int flag=1;
        vector<int> a,circle(len,0);        //vector<int> qi(i,0);
        while(i<len)
        {
                if(DFS(graph,i,circle)==0)  // 1.2.下一个节点，3.当前node。4.初始节点
                a.push_back(i);
                i++;
        }
        return a;
    }
    int DFS(vector<vector<int>>& graph,int node,vector<int>& circle)  //漏了个&，&确实快！
    {
        int next_node,num=0;    //每次递归是个新的node，0起始；有return的node才是非0
        if(graph[node].size()==0) return 0; //这条线没环！||//剪枝，这点没环
 //*****if(circle[node]==1)  return -1;//这个点有环  ...放下方while里进入递归前判断
        circle[node]=1;  //访问了当前节点
        while(num<graph[node].size())
        {
            next_node=graph[node][num++] ;  //next_node=graph[node][num]
            if(circle[next_node]==2)continue;
            if(circle[next_node]==1||DFS(graph,next_node,circle)==-1)  
                return -1;      //这个点有环，下方殃及上方
        }
        circle[node]=2;   //这个点没环！
        return 0;

    }
};