用c语言写：输入一个任意大小的迷宫数据，用非递归的方法求出走出迷宫的路径，并将路径输出。

好的，这是一个比较经典的算法题目，我来为您讲解一下思路。

首先，我们需要用一个二维数组来表示迷宫，1代表墙，0代表道路。假设起点为(0,0)，终点为(m-1,n-1)，其中m和n表示迷宫的行数和列数。

接下来，我们可以使用栈来实现非递归的深度优先搜索算法。具体步骤如下：

1. 将起点入栈，并将其标记为已经访问过。

2. 当栈不为空时，取出栈顶元素，判断其是否为终点。如果是，则说明已经找到了一条路径，输出路径并结束程序。如果不是，则继续执行下一步。

3. 遍历当前节点的邻居节点（上下左右四个方向），如果邻居节点未被访问过且为0，则将其入栈，并将其标记为已经访问过。

4. 重复步骤2和3，直到找到一条路径或者栈为空。

下面是用C语言实现的代码：

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 100

typedef struct {
    int x, y;
} Position;

typedef struct {
    Position data[MAXSIZE];
    int top;
} Stack;

void InitStack(Stack *S) {
    S->top = -1;
}

void Push(Stack *S, Position p) {
    S->data[++S->top] = p;
}

void Pop(Stack *S) {
    S->top--;
}

Position Top(Stack S) {
    return S.data[S.top];
}

int IsEmpty(Stack S) {
    return S.top == -1;
}

int Maze[MAXSIZE][MAXSIZE];
int Visited[MAXSIZE][MAXSIZE];

int m, n;

void PrintPath(Stack S) {
    while (!IsEmpty(S)) {
        Position p = Top(S);
        printf("(%d,%d)\n", p.x, p.y);
        Pop(&S);
    }
}

int main() {
    scanf("%d%d", &m, &n);
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &Maze[i][j]);
            Visited[i][j] = 0;
        }
    }

    Stack S;
    InitStack(&S);

    Position start = {0, 0};
    Push(&S, start);
    Visited[start.x][start.y] = 1;

    while (!IsEmpty(S)) {
        Position cur = Top(S);
        if (cur.x == m-1 && cur.y == n-1) {
            PrintPath(S);
            return 0;
        }

        // 上
        if (cur.x > 0 && Maze[cur.x-1][cur.y] == 0 && !Visited[cur.x-1][cur.y]) {
            Position next = {cur.x-1, cur.y};
            Push(&S, next);
            Visited[next.x][next.y] = 1;
            continue;
        }

        // 下
        if (cur.x < m-1 && Maze[cur.x+1][cur.y] == 0 && !Visited[cur.x+1][cur.y]) {
            Position next = {cur.x+1, cur.y};
            Push(&S, next);
            Visited[next.x][next.y] = 1;
            continue;
        }

        // 左
        if (cur.y > 0 && Maze[cur.x][cur.y-1] == 0 && !Visited[cur.x][cur.y-1]) {
            Position next = {cur.x, cur.y-1};
            Push(&S, next);
            Visited[next.x][next.y] = 1;
            continue;
        }

        // 右
        if (cur.y < n-1 && Maze[cur.x][cur.y+1] == 0 && !Visited[cur.x][cur.y+1]) {
            Position next = {cur.x, cur.y+1};
            Push(&S, next);
            Visited[next.x][next.y] = 1;
            continue;
        }

        // 所有邻居节点都已经访问过，出栈
        Pop(&S);
    }

    printf("No path found\n");
    return 0;
}

注意，这里用到了一个结构体Stack，实现了栈的基本操作。另外，为了方便起见，我们将起点和终点的坐标分别定义为{0,0}和{m-1,n-1}，并且将Visited数组用来记录每个节点是否已经被访问过。