dfs和bfs算法

• 　　1. 存储图的方式一般是有两种的：邻接表和邻接矩阵，一般存储链接矩阵的方式是比较简单的，也便于我们去实现这个临接矩阵，他也就是通俗的二维数组，我们平常用到的那种。
• 　　2. 这里我们主要记录和讲一下bfs和dfs算法之间的一些区别和用法，他们的原理一般人是都知道的，但是他们是怎么来实现的我相信一部分人并没有去真正的实现过，包括我也是（惭愧惭愧），本人算法比较渣，所以过来恶补一下。我就先从dfs开始吧。
  • 　　2.1 dfs 深度优先遍历
    • 　　顾名思义：深度优先，就是一直是往深处遍历，直到没有路走为止，再回过头来找到最开始那个没路的位置换一条路再进行上面那个操作，往深处钻。递归的方式比较简单，下面上一下代码，测试通过。

    • #include<iostream>
      #include <stdio.h>
      #include <string.h>
      #include <windows.h>
      #include <fstream>
      using namespace std;
      
      int array[11][11];
      bool visited[11];
      
      void input_graph(){
      
          for (int i = 1; i <= 10; i++)
              for( int j = 1; j <= 10; j++)
                  cin>>array[i][j];
      }
      
      void dfs_graph(){
          void dfs(int v);
          memset(visited, false, sizeof(visited));
      
          for (int i = 1; i <= 10; i++)// 遍历每一个节点，主要是为了当图不是连通的时候无法访问所有的节点
              if(visited[i] == false)
                  dfs(i);
      }
      
      void dfs(int v){
          //深度遍历每个节点，记录访问过的节点
          int  adjx(int x);
      
          cout<<"当前访问顶点："<<v<<endl;
          visited[v] = true;
      
          int adx = adjx(v);//求临接的顶点
      
          while (adx!=0){//这里就递归的进行深度搜索
              if(visited[adx] == false)
                  dfs(adx);
      
              adx = adjx(v);
          }
      }
      
      int adjx(int x){//找到当前节点的临节点
          for (int i = 0; i <= 10; i++)
              if (array[x][i] == 1 && visited[i] ==false)
                  return i;
      
          return 0;
      }
      
      int main(){
          cout<<"初始化图:"<<endl;
          input_graph();
      
          cout<<"dfs遍历结果:"<<endl;
          dfs_graph();
      
          return 0;
      }

    • 　　我感觉递归的方式还是比较简单的，但是非递归的话比较麻烦，具体可以查看一个这位大哥写的。http://www.cnblogs.com/pengyingh/articles/2396432.html。写的通俗易懂挺好的。
      
      
  • 　　bfs 广度优先遍历
    • 　　这个就和深度不一样了，他这个就相当于是先遍历当前层的，然后再一层一层的往下面进行遍历，也是递归的方式。
    • 　　bfs算法其实就是一种层次遍历算法。从算法描述可以看到该算法要用到队列这一数据结构。我这

      里用STL中的<queue>实现。该算法由于不是递归算法，所以程序流程是清晰的。

      
      

      #include<iostream>
      #include<queue>    
      using namespace std;
      
      int a[11][11];
      bool visited[11];
      
      void store_graph()  
      {
          for(int i=1;i<=10;i++)
              for(int j=1;j<=10;j++)
                  cin>>a[i][j];
      }
      
      void bfs_graph()    
      {
          void bfs(int v);
      
          memset(visited,false,sizeof(visited));
      
          for(int i=1;i<=10;i++)  
              if(visited[i]==false)
                  bfs(i);
      }
      
      void bfs(int v)
      {
          int Adj(int x);
      
          queue<int> myqueue;
          int adj,temp;
      
          cout<<v<<" ";
          visited[v]=true;
          myqueue.push(v);
      
          while(!myqueue.empty())    //队列非空表示还有顶点未遍历到
          {
              temp=myqueue.front();  //获得队列头元素
              myqueue.pop();         //头元素出对
      
              adj=Adj(temp);
              while(adj!=0)
              {
                  if(visited[adj]==false)
                  {
                      cout<<adj<<" ";
                      visited[adj]=true;
                      myqueue.push(adj);   //进对
                  }
      
                  adj=Adj(temp);
              }
          }
      }
      
      int Adj(int x)   
      {
          for(int i=1;i<=10;i++)
              if(a[x][i]==1 && visited[i]==false)
                  return i;
      
          return 0;
      }
      
      int main()
      {
          cout<<"初始化图:"<<endl;
          store_graph();
      
          cout<<"bfs遍历结果:"<<endl;
          bfs_graph();
      
          return 0;
      }