运行广度优先遍历算法，写出输入数据的顺序和程序运行的结果； 改变数据的输入顺序，记录输出结果，并与上次运行结果进行比较； 对于非连通图，前述算法能否实现图的遍历？如何进行改进？。

好的，我会尽力回答您的问题。

首先，广度优先遍历算法是一种用于图形遍历的算法，它从图的一个顶点开始遍历，先访问该顶点的所有邻居，然后再访问邻居的邻居，以此类推，直到遍历完整个图。下面是广度优先遍历算法的伪代码：

BFS(G, s):
    for each vertex u in G:
        u.color = WHITE
        u.d = inf
        u.pi = NIL
    s.color = GRAY
    s.d = 0
    s.pi = NIL
    Q = empty queue
    enqueue(Q, s)
    while Q is not empty:
        u = dequeue(Q)
        for each v in Adj[u]:
            if v.color == WHITE:
                v.color = GRAY
                v.d = u.d + 1
                v.pi = u
                enqueue(Q, v)
        u.color = BLACK

其中，G 表示图，s 表示起始顶点，Adj[u] 表示与顶点 u 相邻接的所有顶点。

假设我们有以下这个无向图：

A -- B
|    |
D -- C

我们可以按照以下顺序输入数据：

G = { A, B, C, D }
Adj[A] = { B, D }
Adj[B] = { A, C }
Adj[C] = { B, D }
Adj[D] = { A, C }
s = A
BFS(G, s)

程序的运行结果是：

A: d=0, pi=NIL
B: d=1, pi=A
C: d=2, pi=B
D: d=1, pi=A

如果我们改变输入数据的顺序，比如这样：

G = { D, C, A, B }
Adj[D] = { A, C }
Adj[C] = { B, D }
Adj[A] = { B, D }
Adj[B] = { A, C }
s = D
BFS(G, s)

那么程序的运行结果也会改变：

D: d=0, pi=NIL
A: d=1, pi=D
C: d=1, pi=D
B: d=2, pi=A

对于非连通图，前述算法可以实现图的遍历，但是需要进行一些改进。具体来说，我们需要在算法中加入一个循环，以确保遍历到所有的顶点。伪代码如下：

BFS(G):
    for each vertex u in G:
        u.color = WHITE
        u.d = inf
        u.pi = NIL
    for each vertex s in G:
        if s.color == WHITE:
            s.color = GRAY
            s.d = 0
            s.pi = NIL
            Q = empty queue
            enqueue(Q, s)
            while Q is not empty:
                u = dequeue(Q)
                for each v in Adj[u]:
                    if v.color == WHITE:
                        v.color = GRAY
                        v.d = u.d + 1
                        v.pi = u
                        enqueue(Q, v)
                u.color = BLACK

其中，G 表示图，Adj[u] 表示与顶点 u 相邻接的所有顶点。

这样，我们就可以遍历到所有的顶点了。