DFS & BFS

DFS 深度优先

BFS 广度优先

DFS或者BFS都是在联通区域内遍历节点的方法

用在二叉树上DFS有preOreder，inOrder，postOrder，BFS就是层次遍历。

在二叉树上的节点，只有两个选择，left 和right，即，对于每一个节点，in 有1个， out 有两个，有向图

在矩阵的节点上，有四个选择，up、down、left和right四种选择，即，即，对于每一个节点，in 有4个， out 有4个，有向图

在surrounded Regions 中可以使用DFS或者BFS来解决问题

下面以4x4 矩阵为例，说明DFS和BFS的工作过程

 #include <stdio.h>
 #include <stdlib.h>
 #include <iostream>
 #include <vector>
 #include <queue>
 #include <stack>
 using namespace std;

 void printArray(int *array, int size)
 {
     for(int i = ; i < size; i++)
         cout << array[i]<< "\t" ;
     cout << endl;
 }

 void printVector(vector<char> array )
 {
     for(int i = ; i <array.size(); i++)
         cout << array[i]<< "\t" ;
     cout << endl;
 }

 void printVector(vector<int> array )
 {
     for(int i = ; i <array.size(); i++)
         cout << array[i]<< "\t" ;
     cout << endl;
 }

 class Solution {
             queue<pair<int, int> > m_que;
     public:
         void dfs(vector<vector<int> > &board, int i, int j)
         {
             size_t row = board.size();
             size_t col = board[].size();

             if(i <  || i > row- || j <  || j > col-)
                 return;
             if( board[i][j] == INT_MAX)
                 return;
                 cout << "(" << i <<"," << j << ") = " <<  board[i][j] << endl ;
             board[i][j] = INT_MAX;//tag, in order to reverse back
             dfs(board, i, j-);
             dfs(board, i, j+);
             dfs(board, i-, j);
             dfs(board, i+, j);
         }

         void fill(vector<vector<int> > &board, int i, int j){
             size_t row = board.size();
             size_t col = board[].size();

             if(i< || i>=row || j< || j>=col || board[i][j]== INT_MAX)
                 return;

             pair<int, int> p ;
             p.first = i;
             p.second = j;
             m_que.push(p);

             cout << "(" << i <<"," << j << ") = " <<  board[i][j] << endl ;
             board[i][j]= INT_MAX;

         }

         void bfs(vector<vector<int> > &board, int i, int j)
         {
             fill(board, i, j);

             while(!m_que.empty())
             {
                 pair<int, int> p = m_que.front() ;
                 m_que.pop();

                 i = p.first;
                 j = p.second;

                 fill(board, i, j-);
                 fill(board, i, j+);
                 fill(board, i-, j);
                 fill(board, i+, j);
             }

         }

         void dfs(vector<vector<int> > board)
         {
             if (board.empty()) return;

             dfs(board,  ,);

         }
         void bfs(vector<vector<int> > board)
         {
             if (board.empty()) return;

             bfs(board,  ,);

         }
 };

 int main()
 {
     vector<vector<int> > board;
     vector<int> a;
     a.resize(, );

     a[] = ;
     a[] = ;
     a[] = ;
     a[] = ;
     board.push_back(a);

     a[] = ;
     a[] = ;
     a[] = ;
     a[] = ;
     board.push_back(a);

     a[] = ;
     a[] = ;
     a[] = ;
     a[] = ;
     board.push_back(a);

     a[] = ;
     a[] = ;
     a[] = ;
     a[] = ;
     board.push_back(a);

 //    board.clear();
     Solution sl;

     for(int i = ; i < board.size(); i++)
         printVector(board[i]);

     cout <<endl;
     cout << "dfs" <<endl;
     sl.dfs(board);
     cout << "bfs" <<endl;
     sl.bfs(board);

     for(int i = ; i < board.size(); i++)
         printVector(board[i]);

     return ;
 }

打印结果

[root@localhost surroundedRegions]# ./a.out

矩阵
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

dfs
(2,2) = 10
(2,1) = 9
(2,0) = 8
(1,0) = 4
(1,1) = 5
(1,2) = 6
(1,3) = 7
(0,3) = 3
(0,2) = 2
(0,1) = 1
(0,0) = 0
(2,3) = 11
(3,3) = 15
(3,2) = 14
(3,1) = 13
(3,0) = 12

bfs
(2,2) = 10
(2,1) = 9
(2,3) = 11
(1,2) = 6
(3,2) = 14
(2,0) = 8
(1,1) = 5
(3,1) = 13
(1,3) = 7
(3,3) = 15
(0,2) = 2
(1,0) = 4
(3,0) = 12
(0,1) = 1
(0,3) = 3
(0,0) = 0