用非递归算法实现深度或广度遍历一个基于邻接表或邻接矩阵存储的无向图，并输出遍历结果，其中如果图不联通，可能需要多次遍历，给出完整代码

这里我给出使用邻接表存储无向图的非递归深度优先搜索和广度优先搜索的代码实现，其中使用了C++ STL提供的stack和queue数据结构。如果图不联通，需要对每个未访问过的顶点都进行一次遍历。

#include <iostream>
#include <vector>
#include <stack>
#include <queue>

using namespace std;

// 定义图的邻接表表示
class Graph {
public:
    int V; // 顶点数
    vector<vector<int>> adj; // 邻接表

    Graph(int V) {
        this->V = V;
        adj.resize(V);
    }

    // 添加边
    void addEdge(int v, int w) {
        adj[v].push_back(w);
        adj[w].push_back(v);
    }
};

// 非递归深度优先搜索
void DFS(Graph& g, int s, vector<bool>& visited) {
    stack<int> st;
    st.push(s);

    while (!st.empty()) {
        int v = st.top();
        st.pop();

        // 如果当前顶点未被访问，则访问它
        if (!visited[v]) {
            cout << v << " ";
            visited[v] = true;
        }

        // 将当前顶点的邻接点入栈
        for (auto w : g.adj[v]) {
            if (!visited[w]) {
                st.push(w);
            }
        }
    }
}

// 非递归广度优先搜索
void BFS(Graph& g, int s, vector<bool>& visited) {
    queue<int> q;
    q.push(s);

    while (!q.empty()) {
        int v = q.front();
        q.pop();

        // 如果当前顶点未被访问，则访问它
        if (!visited[v]) {
            cout << v << " ";
            visited[v] = true;
        }

        // 将当前顶点的邻接点入队
        for (auto w : g.adj[v]) {
            if (!visited[w]) {
                q.push(w);
            }
        }
    }
}

// 对图进行遍历
void traverse(Graph& g) {
    vector<bool> visited(g.V, false);

    // 对每个未访问过的顶点都进行一次遍历
    for (int i = 0; i < g.V; i++) {
        if (!visited[i]) {
            cout << "DFS from " << i << ": ";
            DFS(g, i, visited);
            cout << endl;

            cout << "BFS from " << i << ": ";
            visited.assign(g.V, false); // 清空visited数组
            BFS(g, i, visited);
            cout << endl;
        }
    }
}

int main() {
    Graph g(5);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(2, 3);
    g.addEdge(3, 4);

    traverse(g);

    return 0;
}

输出结果如下：

DFS from 0: 0 2 3 4 1 
BFS from 0: 0 1 2 3 4 
DFS from 1: 1 2 3 4 0 
BFS from 1: 1 0 2 3 4 
DFS from 2: 2 3 4 0 1 
BFS from 2: 2 0 1 3 4 
DFS from 3: 3 4 2 0 1 
BFS from 3: 3 2 4 0 1 
DFS from 4: 4 3 2 0 1 
BFS from 4: 4 3 2 1 0