简单是简单，可是论坛不提倡帮做作业的，好歹你写个框架啊。

当前坐标 x y
表示当前走到了 map[x][y] 这个位置
向上走 map[x-1][y]
向下走 map[x+1][y]
向左走 map[x][y-1]
向右走 map[x][y+1]
比较简单的这里你用switch处理就完事了
注意 边界检查就差不多了

关键是怎么去检查边界...这一步不会

因为我的代码是先移动的，它会移动到索引为-1的地方，这就直接异常了

..对不起 忘了说了
我就是那个变界检查不会 怎么让我的移动不会走出那个10×10的空间

我想过声明一个12×12的 但是太麻烦了

你都说了，先移动有问题，那就先检查后移动呗。

如果不用递归做的话，移动前应先保存当前坐标，移动后发现坐标异常就恢复，正常则继续。递归做则原坐标在栈中，返回就行了。

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

void chuShiHua(char qiPan[][12], bool panDuan[][12]);
int suiJiShu(void);
bool jianCha(bool panDuan[][12], char ziMu);
void yiDong(bool panDuan[][12], char qiPan[][12]);
void daYin(char qiPan[][12]);

int hang = 1, lie = 1;
char ziMu = 'A';

int main(void)
{
    char qiPan[12][12];
    bool panDuan[12][12];


    srand((unsigned)time(NULL));
    chuShiHua(qiPan, panDuan);

    qiPan[1][1] = ziMu;
    panDuan[1][1] = true;

    while (jianCha(panDuan, ziMu))
        yiDong(panDuan, qiPan);

    daYin(qiPan);

    return 0;
}

/* 初始化数组 */
void chuShiHua(char qiPan[][12], bool panDuan[][12])
{
    for (int x = 0; x < 12; x++)
        for (int y = 0; y < 12; y++)
            qiPan[x][y] = '.';

    for (int x = 0; x < 12; x++)
        for (int y = 0; y < 12; y++)
            if (x == 0 || y == 0 || x == 11 || y == 11)
                panDuan[x][y] = true;
            else
                panDuan[x][y] = false;
}

/* 生成随机数 */
int suiJiShu(void)
{
    return rand() % 4;
}

/* 判断,如果能继续则返回true;不能继续则返回false */
bool jianCha(bool panDuan[][12], char ziMu)
{
    if (ziMu == 'Z')
        return false;
    if (panDuan[hang - 1][lie] && panDuan[hang + 1][lie])
        if (panDuan[hang][lie - 1] && panDuan[hang][lie + 1])
            return false;

    return true;
}

/* 利用随机数进行方向的移动 */
void yiDong(bool panDuan[][12], char qiPan[][12])
{
    bool zuobiao = true;
    switch (suiJiShu())
    {
    case 0:hang--;
        if (panDuan[hang][lie])
        {
            hang++;
            zuobiao = false;
        }
        break;
    case 1:lie++;
        if (panDuan[hang][lie])
        {
            lie--;
            zuobiao = false;
        }
        break;
    case 2:hang++;
        if (panDuan[hang][lie])
        {
            hang--;
            zuobiao = false;
        }
        break;
    case 3:lie--;
        if (panDuan[hang][lie])
        {
            lie++;
            zuobiao = false;
        }
        break;
    }

    if (zuobiao)
    {
        ziMu++;
        qiPan[hang][lie] = ziMu;
        panDuan[hang][lie] = true;
    }
}

/* 打印 */
void daYin(char qiPan[][12])
{
    for (int x = 1; x < 11; x++)
    {
        for (int y = 1; y < 11; y++)
            putchar(qiPan[x][y]);
        putchar('\n');
    }
        
}


我成功了 不过不是声明的10×10数组 ，而是12×12  

恭喜楼主！
那我也给出我用递归完成的代码，供楼主参考。只要修改“#define N 10”为“#define N 12”，就可以做12×12：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 10
int aaaa(char a[][N], int x, int y, char c)
{
    int i, j, k;
    if (x < 0 || y < 0 || x>N-1 || y>N-1 || a[x][y])return 0;  //坐标越界或坐标点上已经有字母则返回0
    a[x][y] = c;
    if (c == 'Z')return 1;    //26个字母全部用完返回1
    j = rand() % 4;
    for (i = 0; i < 4; i++)
    {
        k = ((i + j) % 4) * 2 + 1;
        if (aaaa(a, x + k % 3 - 1, y + k / 3 - 1, c + 1))return 1;  //步进递归
    }
    return 1;                //无路可走返回1
}
void main()
{
    int i, j;
    char a[N][N] = { 0 };
    srand(clock());
    aaaa(a, 0, 0, 'A');
    for (i = 0; i < N; i++, printf("\n"))
        for (j = 0; j < N; j++)
            if (a[i][j])printf("%c", a[i][j]);
            else printf(".");
    system("pause");
}