假设一个无向图是非连通的，采用邻接表作为存储结构，试设计一个算法，输出图中各连通分量的顶点序列。

该问题可以采用深度优先搜索（DFS）算法来解决。

具体步骤如下：

1. 从图中任意一个未被遍历的顶点开始，采用DFS搜索遍历它所在的连通分量。

2. 遍历过程中，将经过的顶点标记为已访问。

3. 遍历完一个连通分量后，记录下其中的所有顶点序列。

4. 如果还有未被遍历的顶点，则返回步骤1继续进行遍历。

下面是该算法的示例代码，其中使用了C++语言和邻接表作为存储结构：

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

using namespace std;

const int MAXN = 1000; // 最大顶点数
vector<int> adj[MAXN]; // 邻接表存储结构
bool visited[MAXN];    // 标记数组，记录每个顶点是否已被访问

void DFS(int u, vector<int>& comp) {
    visited[u] = true;  // 标记该顶点已被访问
    comp.push_back(u);  // 将该顶点加入到当前连通分量的顶点序列中
    for (int i = 0; i < adj[u].size(); i++) {
        int v = adj[u][i];  // v是u的一个邻居顶点
        if (!visited[v]) {
            DFS(v, comp);  // 对v进行DFS遍历
        }
    }
}

void findComponents(int n) {
    for (int i = 0; i < n; i++) {
        visited[i] = false;  // 初始化visited数组
    }

    vector<vector<int>> components;  // 所有连通分量的顶点序列
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            vector<int> comp;  // 当前连通分量的顶点序列
            DFS(i, comp);      // 对i所在的连通分量进行DFS遍历
            components.push_back(comp);
        }
    }

    // 输出所有连通分量的顶点序列
    for (int i = 0; i < components.size(); i++) {
        cout << "Component " << i + 1 << ": ";
        for (int j = 0; j < components[i].size(); j++) {
            cout << components[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    int n, m;
    cin >> n >> m;

    // 读入图的边
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    findComponents(n);

    return 0;
}

该算法的时间复杂度为O(n+m)，其中n是顶点数，m是边数。