编写算法实现采用孩子兄弟链表作为存储结构的普通树的层序遍历算法。

### 回答1：
层序遍历算法可以通过队列实现。具体步骤如下：

1. 将根节点入队列。
2. 当队列不为空时，依次取出队列中的节点，访问该节点，并将该节点的所有孩子节点依次入队列。
3. 重复步骤2，直到队列为空。

对于采用孩子兄弟链表作为存储结构的普通树，可以按照以下方式实现层序遍历算法：

1. 定义一个队列，用于存储待访问的节点。
2. 将根节点入队列。
3. 当队列不为空时，依次取出队列中的节点，访问该节点，并将该节点的所有兄弟节点依次入队列。
4. 重复步骤3，直到队列为空。

需要注意的是，由于孩子兄弟链表的特殊性质，每个节点的兄弟节点可以通过链表的方式依次访问。因此，在访问一个节点的所有兄弟节点时，只需要依次遍历该节点的兄弟节点即可。

### 回答2：
普通树是指树中每个节点的子节点数量不限，且没有限定子节点之间的先后顺序。层序遍历是一种广度优先搜索算法，即按层次逐层遍历树结构，从根节点开始，依次访问每一层的节点，直到最后一层。

采用孩子兄弟链表作为存储结构的普通树，每个节点可以维护一个指向其第一个子节点和第一个兄弟节点的指针，根据这个指针，可以方便地访问每个节点的子节点和兄弟节点。层序遍历需要借助队列数据结构，将每个要访问的节点依次入队和出队，按照先入先出的方式完成遍历。

具体实现步骤如下：

（1）定义一个队列，将根节点入队。

（2）对于队列中每个节点，依次访问其所有孩子节点，并将孩子节点入队。

（3）从队列中弹出已经访问过的节点。

（4）重复步骤（2）和（3），直到队列为空为止。

示例代码如下：

class TreeNode:
    def __init__(self, value):
        self.val = value
        self.child = None
        self.sibling = None

def level_order_traversal(root):
    if not root:
        return []

    result = []
    queue = [root]

    while queue:
        level = []
        for i in range(len(queue)):
            node = queue.pop(0)
            level.append(node.val)
            child = node.child
            while child:
                queue.append(child)
                child = child.sibling
        
        result.append(level)

    return result

在上面的代码中，每个节点都有一个child和sibling指针，通过while循环遍历所有子节点和兄弟节点，并依次入队，最后按照每层的顺序将节点值加入对应层的列表中。遍历完成后，将所有层的列表加入到结果列表中，返回结果。

### 回答3：
普通树采用孩子兄弟链表作为存储结构时，其层序遍历算法主要有以下几个步骤：

1.首先判断树是否为空，若为空则无需遍历。

2.创建一个队列，将根节点入队。

3.进入循环，当队列不为空时，取出队首元素，并将其输出。

4.检查当前节点是否有孩子节点，若有，则将其孩子依次入队。

5.检查当前节点是否有兄弟节点，若有，则将其兄弟依次入队。

6.重复第3至第5步，直到队列为空，则完成层序遍历。

具体实现过程如下：

定义一个结构体来表示节点：

typedef struct TreeNode
{
char data;
struct TreeNode *firstchild,*rightsib;
}TreeNode,*Tree;

定义一个队列结构体，用于存储遍历时的节点：

typedef struct QNode
{
Tree data;
struct QNode *next;
}QNode,*Queue;

定义入队函数enqueue和出队函数dequeue：

void enqueue(Queue *q,Tree data)
{
Queue newnode=(Queue)malloc(sizeof(QNode));
newnode->data=data;
newnode->next=NULL;
if((*q)==NULL) (*q)=newnode;
else
{
Queue p=*q;
while(p->next!=NULL)
{
p=p->next;
}
p->next=newnode;
}
}

Tree dequeue(Queue *q)
{
Queue p=*q;
Tree data=p->data;
(*q)=p->next;
free(p);
return data;
}

定义层序遍历函数LevelOrder：

void LevelOrder(Tree t)
{
Queue q=NULL;
if(t==NULL) return;
enqueue(&q,t);
while(q!=NULL)
{
Tree p=dequeue(&q);
printf("%c",p->data);
if(p->firstchild!=NULL) enqueue(&q,p->firstchild);
if(p->rightsib!=NULL) enqueue(&q,p->rightsib);
}
}

在主函数中，创建一棵孩子兄弟链表存储的树，并调用层序遍历函数LevelOrder输出结果：

int main()
{
Tree A=(Tree)malloc(sizeof(TreeNode)); A->data='A'; //创建根节点A
Tree B=(Tree)malloc(sizeof(TreeNode)); B->data='B'; //创建子节点B
Tree C=(Tree)malloc(sizeof(TreeNode)); C->data='C'; //创建子节点C
Tree D=(Tree)malloc(sizeof(TreeNode)); D->data='D'; //创建子节点D
Tree E=(Tree)malloc(sizeof(TreeNode)); E->data='E'; //创建子节点E
Tree F=(Tree)malloc(sizeof(TreeNode)); F->data='F'; //创建子节点F
A->firstchild=B;
B->rightsib=C;
C->rightsib=D;
B->firstchild=E;
E->rightsib=F;

printf("层序遍历结果：");
LevelOrder(A);
return 0;
}

输出结果为：ABCEFCD。