深入浅出BFS(2)：自顶向下(Top-down method) & 自底向上(Bottom-up method)

BFS 自顶向下(Top-down method) VS 自底向上(Bottom-up method)

BFS孤立点的处理

1. Top-down method

Top-down方法是传统的层同步BFS算法。主要步骤为：

1、扫描当前层的所有顶点；
2、检索其所有的邻居顶点；
3、添加未访问的邻居顶点到下一层。

但遇到的问题是：

1、冗余的边检索；
2、更新冲突。

2. Bottom-up method

Bottom-up 方法可解决top-down所遇到的问题。主要步骤为：

1、扫描未访问的顶点；
2、检索其邻居顶点是否在当前层，若有，则中止并检索下一顶点；
3、将该顶点添加到下一层中

BFS : Top-down method and Bottom-up method

#include <iostream>
#include <list>
#include <vector>
#include <algorithm>   
using namespace std;

class Graph {
	int numVertices;a
	list<int>* adjLists;
	bool* visited;
	public:
	    Graph(int vertices);
	    void addEdge(int src, int dest);
	    void BFS(int startVertex);
        void BFS2(int startVertex);
        void BFS3(int startVertex);
};

// Create a graph with given vertices, and maintain an adjacency list
Graph::Graph(int vertices) {
	numVertices = vertices;
	adjLists = new list<int>[vertices];
}

// Add edges to the graph
void Graph::addEdge(int src, int dest) {
	adjLists[src].push_back(dest);
	adjLists[dest].push_back(src);
}

// BFS 单队列实现
void Graph::BFS(int startVertex) {
	visited = new bool[numVertices];
	for (int i = 0; i < numVertices; i++)
	    visited[i] = false;
	list<int> queue;
	visited[startVertex] = true;
	queue.push_back(startVertex);
	
    list<int>::iterator i;
    cout << "Visited: ";
    while (!queue.empty()) {
		int currVertex = queue.front();
		cout << currVertex << " ";
		queue.pop_front();
		for (i = adjLists[currVertex].begin(); i != adjLists[currVertex].end(); ++i) {
			int adjVertex = *i;
			if (!visited[adjVertex]) {
				visited[adjVertex] = true;
				queue.push_back(adjVertex);
			}
		}
	}
    cout << endl;
}
//BFS2(双队列：top-bottom模式)
void Graph::BFS2(int startVertex){
    visited = new bool[numVertices];
    for(int i=0; i<numVertices;i++){
        visited[i]=false;
    }
    list<int>fronter_queue, next_queue;
    visited[startVertex]=true;
    fronter_queue.push_back(startVertex);

    list<int>::iterator i;
    cout << "Visited: ";
    while(!fronter_queue.empty()){
        int currVertex = fronter_queue.front();
        cout <<currVertex << " ";
        fronter_queue.pop_front();
        for(i=adjLists[currVertex].begin(); i!=adjLists[currVertex].end(); i++){
            int adjVertex = *i;
            if(!visited[adjVertex]){
                visited[adjVertex]=true;
                next_queue.push_back(adjVertex);
            }
        }
        if(fronter_queue.empty()){
            //fronter_queue=next_queue;
            //next_queue.clear();
            swap(fronter_queue, next_queue);
        }
    }
    cout << endl;
}

//BFS3(双队列：bottom-up模式)
void Graph::BFS3(int startVertex){
    visited = new bool[numVertices];
    for(int i=0; i<numVertices;i++){
        visited[i]=false;
    }
    visited[startVertex]=true;
    
    list<int>fronter_queue, next_queue;
    
    fronter_queue.push_back(startVertex);
    
    list<int>::iterator it; 
    cout << "Visited: ";
    
    while(!fronter_queue.empty()){
        int currVertex = fronter_queue.front();
        cout << currVertex << " ";
        fronter_queue.pop_front();
        for(int u = 0; u < numVertices; u++){
            if(visited[u]==false){
                for(it = adjLists[u].begin(); it!=adjLists[u].end();it++){
                    if(find(fronter_queue.begin(), fronter_queue.end(), *it)!=fronter_queue.end()){
                        next_queue.push_back(u);
                        visited[u]=true;
                        break;
                    }
                }
            }
        }
        //
        if(fronter_queue.empty()){
            swap(fronter_queue,next_queue);
        }
    }
    cout << endl;
}

int main() {
	Graph g(8);
	g.addEdge(0, 1);
	g.addEdge(0, 2);
	g.addEdge(0, 3);
	g.addEdge(1, 2);
	g.addEdge(1, 4);
	g.addEdge(2, 3);
	g.addEdge(2, 5);
	g.addEdge(2, 6);
    g.addEdge(3, 7);
    g.addEdge(4, 5);
    g.addEdge(5, 6);
    g.addEdge(6, 7);
	g.BFS(1);
    g.BFS2(1);
    g.BFS3(1);
	return 0;
}