C语言实现以下问题：创建迷宫，设置通道，墙壁；求解从指定入口到出口的所有路径，并用队列求解最短路径。

好的，让我来回答你的问题。

首先，创建迷宫可以用二维数组来表示，其中每个格子的值表示该位置是通道还是墙壁（可以用0表示通道，1表示墙壁）。如下所示：

int maze[ROWS][COLS] = {
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 0, 1, 0, 0, 0, 0, 1},
{1, 0, 1, 0, 1, 0, 1, 1, 0, 1},
{1, 0, 1, 0, 0, 0, 0, 1, 0, 1},
{1, 0, 1, 1, 1, 1, 0, 1, 0, 1},
{1, 0, 0, 0, 0, 1, 0, 1, 0, 1},
{1, 1, 1, 1, 0, 0, 0, 1, 0, 1},
{1, 0, 0, 0, 0, 1, 1, 1, 0, 1},
{1, 0, 1, 1, 0, 0, 0, 0, 0, 1},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
};

其中，ROWS和COLS分别表示迷宫的行数和列数。

其次，我们可以用广度优先搜索算法（BFS）求解从指定入口到出口的所有路径，并用队列求解最短路径。BFS算法的基本原理是从起点开始，先访问它的所有邻居节点，然后再访问邻居节点的邻居节点，以此类推，直到找到终点或者所有节点都被访问为止。

下面是求解最短路径的代码示例：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100
#define ROWS 10
#define COLS 10
#define INFINITY 1000000

typedef struct {
int i, j; //位置
} PosType;

typedef struct {
int ord; //通道块的“权值”，即从起点到此位置的步数
PosType seat; //位置
int dir; //下一步走的方向
} ElemType;

typedef struct {
ElemType *base;
int front, rear;
} Queue;

void InitQueue(Queue *Q) {
Q->base = (ElemType *)malloc(MAXSIZE * sizeof(ElemType));
Q->front = Q->rear = 0;
}

void EnQueue(Queue *Q, ElemType e) {
if ((Q->rear+1)%MAXSIZE == Q->front) {
printf("队列已满！\n");
return;
}
Q->base[Q->rear] = e;
Q->rear = (Q->rear+1)%MAXSIZE;
}

ElemType DeQueue(Queue *Q) {
ElemType e;
if (Q->front == Q->rear) {
printf("队列为空！\n");
exit(0);
}
e = Q->base[Q->front];
Q->front = (Q->front+1)%MAXSIZE;
return e;
}

int Maze[ROWS][COLS] = { // 迷宫
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 0, 1, 0, 0, 0, 0, 1},
{1, 0, 1, 0, 1, 0, 1, 1, 0, 1},
{1, 0, 1, 0, 0, 0, 0, 1, 0, 1},
{1, 0, 1, 1, 1, 1, 0, 1, 0, 1},
{1, 0, 0, 0, 0, 1, 0, 1, 0, 1},
{1, 1, 1, 1, 0, 0, 0, 1, 0, 1},
{1, 0, 0, 0, 0, 1, 1, 1, 0, 1},
{1, 0, 1, 1, 0, 0, 0, 0, 0, 1},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
};

int visit[ROWS][COLS]; // 记录迷宫中的点是否已访问过
Queue Q; // 队列

// 初始化visit
void initVisit() {
int i, j;
for(i=0; i<ROWS; i++) {
for(j=0; j<COLS; j++) {
visit[i][j] = 0;
}
}
}

// i,j是当前迷宫中的位置，dir是从上一个位置到达这个位置需要走的方向
// dir=0表示从上一个位置往上走，dir=1表示从上一个位置往右走，...
void Visit(int i, int j, int dir, int step, PosType *end) {
if (i == end->i && j == end->j) { // 到达终点
printf("从出口到入口的路径如下：\n");
PrintPath(i, j);
printf("\n从出口到入口的最短路径长度为：%d\n", step);
exit(0);
}
visit[i][j] = 1; // 标记当前位置已访问
ElemType e;
e.ord = step;
e.seat.i = i;
e.seat.j = j;
e.dir = dir;
EnQueue(&Q, e); // 进队列
}

void BFS(PosType start, PosType end) {
// 八个方向：上、下、左、右、左上、右上、左下、右下
int di[8] = {-1,1,0,0,-1,-1,1,1};
int dj[8] = {0,0,-1,1,-1,1,-1,1};
int i, j, Line;
// 按层序号逐个访问
ElemType e;
visit[start.i][start.j] = 1;
e.ord = 0;
e.seat = start;
e.dir = 0;
EnQueue(&Q, e);
while (Q.front != Q.rear) {
e = DeQueue(&Q); // 出队列
i = e.seat.i; // 取出位置信息
j = e.seat.j;
Line = e.ord;
// 枚举8个方向上的可行的下一个位置
for (int k = 0; k < 8; k++) {
int ni = i + di[k];
int nj = j + dj[k];
if (Maze[ni][nj] == 0 && visit[ni][nj] == 0) { // 如果下一个位置是通道，并且没有被访问过
Visit(ni, nj, k, Line+1, &end);
// 如果当前位置是终点则结束搜索，输出路径并退出程序
}
}
}
}

// 回溯法输出路径
void PrintPath(int i, int j) {
ElemType position[ROWS*COLS];
int top = -1;
ElemType e;
e.seat.i = i;
e.seat.j = j;
e.ord = -1; // 标记为路径上的点
position[++top] = e;
while (top >= 0) {
e = position[top--];
if (e.ord == -1) {
printf("(%d,%d) ", e.seat.i, e.seat.j);
} else {
printf("(%d,%d)->", e.seat.i, e.seat.j);
}
if (top >= 0 && position[top].ord == e.ord-1) {
continue;
}
// 查找e的前驱位置
int k;
for (k = 0; k < 8; k++) {
if ((e.dir+6)%8 == k || (e.dir+7)%8 == k || (e.dir+8)%8 == k) {
continue;
}
int ni = e.seat.i + di[k];
int nj = e.seat.j + dj[k];
if (visit[ni][nj] == 1 && e.ord-1 == Q.base[visitToQueue(ni,nj)].ord) {
break;
}
}
if (k < 8) {
// e有前驱位置
ElemType pre;
pre.seat.i = e.seat.i + di[k];
pre.seat.j = e.seat.j + dj[k];
pre.ord = e.ord - 1;
pre.dir = k;
position[++top] = pre;
}
}
}

int visitToQueue(int i, int j) {
int k;
for (k = Q.front; k != Q.rear; k=(k+1)%MAXSIZE) {
if (Q.base[k].seat.i == i && Q.base[k].seat.j == j) {
return k;
}
}
}

int main() {
PosType start = {1, 1};
PosType end = {ROWS-2, COLS-2};
InitQueue(&Q);
initVisit();
BFS(start, end);
printf("没有可行路径！\n");
return 0;
}

需要注意的是，以上代码中的PrintPath函数使用了回溯法输出路径，而visitToQueue函数用于将visit数组中的位置与队列中的元素对应起来。这样，我们就可以求解从指定入口到出口的所有路径，并用队列求解最短路径了。

希望我的回答能够帮助到你，如果还有不明白的地方，请随时提问！