/*  迷宫数组，     起点坐标，   终点坐标   */
void mazepath(mazetype maze,postype start,postype end)
{
 int i,j;
 postype direc[4]={{0,1},{1,0},{0,-1},{-1,0}};
 sqstack s;
 postype e;
 mazepiece piece,temp;
 e=start;
 initstack(&s);
 initgr();
 printf("The blue is wall,the white the throughfare\nThe yellow is start seat,the blue is end seat.");
 printf("\nPress any key to the next step!\n");
 for(j=0;j<10;j++)
    {
    for(i=0;i<10;i++)
      {
          if(maze[j][i]==0) /* 画出迷宫图 */
            box(100+i*25,100+j*25,125+i*25,125+j*25,1);/* 墙壁，蓝色 */
          else
            box(100+i*25,100+j*25,125+i*25,125+j*25,7);/* 通路，白色 */
      }
    }
 if(maze[start.x][start.y]==1)
    box(100+start.x*25,100+start.y*25,125+start.x*25,125+start.y*25,5);/* 画出起点块*/
 else
    {printf("you choose a wrong start seat!\n");getch();
     exit();}
 if(maze[end.x][end.y]==1)
    box(100+end.x*25,100+end.y*25,125+end.x*25,125+end.y*25,5);/* 画出终点块
    */
 else
    {printf("you choose a wrong end seat!\n");getch();
     exit();}
 do{
     if(maze[e.x][e.y]==1)/* 如果是通路 */
     {   /* 用红色方块标记 */
         box(100+e.y*25,100+e.x*25,125+e.y*25,125+e.x*25,4);
         footprint(e);/* 留下脚印 */
         piece.seat=e;
         piece.direction=0;
         push(&s,piece);/* 把走过的迷宫块压入栈 */
         if(e.x==end.x&&e.y==end.y)/* 若到达终点 */
            break;
         e=nextpos(e,piece.direction);/* 往下一个迷宫块走 */
         getch();
     }
     else /* 若当前迷宫块是不通的 */
     {
         if(length(&s)!=0)/* 若栈不空 */
         {
             temp=pop(&s);
             while(temp.direction==4&&length(&s)!=0)/* 若四个方向都试了栈不空 */
             {  /* 消除红色方块标记 */
                box(100+temp.seat.y*25,100+temp.seat.x*25,125+temp.seat.y*25,125+temp.seat.x*25,4);
                maze[temp.seat.x][temp.seat.y]=3;/* 3为不能通过的 */
                temp=pop(&s);
              }
             if(temp.direction<4)
             {
                 temp.direction++;/* 取另外一个方向 */
                 i=maze[temp.seat.x+direc[temp.direction].x][temp.seat.y+direc[temp.direction].y];
                 if(i==2||i==3)/* 若当前为走过的或不通的路,直接取下一个方向 */
                    temp.direction++;
                 push(&s,temp);
                 e=nextpos(temp.seat,temp.direction);
             }
         }
     }
 }while(length(&s)!=0);
 if(length(&s)!=0)
    {
        printf("    the thoroughfare's seat is:\n");
        while(length(&s)!=0)
            {
                temp=pop(&s);
                printf("(%d,%d) ",temp.seat.x,temp.seat.y);
            }
    }
 else
    printf("\n\n\n     you made a wrong maze!");
 getch();
 closegraph();
 exit();
}

void main()
{
 int i,j;
 char m;
 postype start,end;
 line2:printf("\n\n\n\n\n    1-------------make a maze yourself");
 printf("\n\n\n\n\n    2-------------use a maze of system");
 line:m=getch();
 switch((int)m-27)
 {
     case 23:start.x=1;start.y=1;
            end.x=8;end.y=8;
            mazepath(maze,start,end);
     case 22:initgr();
            printf("\nplease input '0' or '1' to make maze,'0' is wall,'1' is thoroughfare\n");
            rectangle(124,124,326,326);
            for(i=0;i<8;i++)
            {
                printf("\n");
                for(j=0;j<8;j++)
                {
                    line1:m=getch();
                    if((int)m==48)
                        {maze[i+1][j+1]=(int)m-48;box(125+j*25,125+i*25,150+j*25,150+i*25,1);}
                    else if((int)m==49)
                        {maze[i+1][j+1]=(int)m-48;box(125+j*25,125+i*25,150+j*25,150+i*25,7);}
                    else
                         goto line1;
                 } /* for2 */
             }/* for1 */
             printf("\n\n\n\n\n\n\n\n\n\n\n\ninput the start seat(use number from 1-8):(x  y)");
             scanf("%d",&start.x);scanf("%d",&start.y);
             printf("\ninput the end seat(use number from 1-8):(x  y)");
             scanf("%d",&end.x);scanf("%d",&end.y);
             mazepath(maze,start,end);
             closegraph();
      case 0:exit();
      default:printf("please choose!");goto line;
  }/* switch */

 }/* main */

我原来也做了一个,图形比较直观,而且可以修改地图,很有意思的:
/*
  Name:  迷宫的算法
  Copyright:
  Author:
  Date: 23-04-06 20:53
  Description:
 1。建立迷宫（外围建筑围墙），可选择人工创建迷宫或计算机随机创建迷宫，还可修改迷宫
 2。设置入口和出口。
 3。寻找最短路径。
 4。若找到可行路径，打印路径，否则报告错误。
*/

#include <iostream>
#include <time.h>
using namespace std;

const int M = 20;  //最大行数
const int N = 20;   //最大列数
enum {OPEN, CLOSE, PASSED, ROAD=-1}; //分别表示该点通，不通，已走和属于所选路径

class MiGong{
      struct stype{//存储每个路径点的有关数据；横坐标，纵坐标和其前驱在数组中的位置
            int x;
            int y;
            int pre;
      } way[M*N];

      int zx[4];//存储东南西北四个方向所对应的x的值
      int zy[4];//存储东南西北四个方向所对应的y的值
      int begin[2];//存储入口坐标
      int end[2]; //存储出口坐标
      int map[M+2][N+2];//存储迷宫地图
      int c_map[M+2][N+2];//存储迷宫地图拷贝
public:
      MiGong(); //构造函数，建立一个处处都关闭的迷宫

      void BuildMiGong(); //建立迷宫地图
      void PerfectMiGong();//修正迷宫地图
      void CopyMiGong();  //拷贝迷宫地图

      void GetBegin();//创建入口坐标
      void GetEnd(); //创建出口坐标
      bool IsBegin(int x, int y);//判断该点是否为入口
      bool IsEnd(int x, int y); //判断该点是否为出口

      bool SearchWay(); //寻找路径
      void PutWay(int rear);//把路径显示到迷宫中

      void PrintMiGong();//输出迷宫地图
      void PrintWay();//输出路径
};

MiGong::MiGong()//构造函数，建立一个处处都关闭的迷宫
{
      for (int i=0; i<M+2; i++)
            for (int j=1; j<=N; j++)
            {
                  if (i==0 || i==M+1)
                        map[i][j] = j;
                  else
                        map[i][j] = CLOSE;
            }
      for (int i=0; i<M+2; i++)
           map[i][0] = i;
      for (int i=0; i<M+2; i++)
           map[i][N+1] = i;

      zx[0]=1; zx[1]=0; zx[2]=-1; zx[3]=0;
      zy[0]=0; zy[1]=-1;zy[2]=0;  zy[3]=1;
}

void MiGong::GetBegin()//创建入口坐标
{
      do{
            cout << "请输入入口坐标：" << endl;
            cin >> begin[0];
            cin >> begin[1];
      } while (begin[0]<1 || begin[0]>M || begin[1]<1 || begin[1]>N);
}
void MiGong::GetEnd()//创建出口坐标
{
      do{
            cout << "请输入出口坐标：" << endl;
            cin >> end[0];
            cin >> end[1];
      } while (end[0]<1 || end[0]>M || end[1]<1 || end[1]>N);
}
bool MiGong::IsBegin(int x, int y)//判断该点是否为入口
{
      return (x==begin[0] && y==begin[1]) ? 1 : 0;
}
bool MiGong::IsEnd(int x, int y)//判断该点是否为出口
{
      return (x==end[0] && y==end[1]) ? 1 : 0;
}

void MiGong::BuildMiGong() //建立迷宫地图
{
      cout << "请选择建立迷宫的方法： 输入m表示人工建立，输入c表示计算机建立" << endl;
      char choice;
      do{
            cin >> choice;
      } while (choice != 'm' && choice != 'c');

      if (choice == 'm')
      {
            cout << "请输入迷宫地图，0表示通，1表示不通" << endl;
            for (int i=1; i<=M; i++)
                  for (int j=1; j<=N; j++)
                        cin >> map[i][j];
      }
      else
      {
            srand( (unsigned) time(NULL));
            for (int i=1; i<=M; i++)
                  for (int j=1; j<=N; j++)
                        map[i][j] = rand() % 2;
      }
}
void MiGong::PerfectMiGong()//修正迷宫地图
{
      int i, j;
      char choice;
      do{
            do{
                  cout << "请输入需要修改的坐标：（输入0，0结束）" << endl;
                  cin >> i;
                  cin >> j;
            } while (i<0 || i>M || j<0 || j>N);
            fflush(stdin);
            if (i!=0 && j!=0)
            {
                  do{
                        cout << "打开该点输入o，关闭该点输入c" << endl;
                        cin >> choice;
                        fflush(stdin);
                  } while (choice != 'c' && choice != 'o');
                  if (choice == 'o')
                        map[i][j] = OPEN;
                  else
                        map[i][j] = CLOSE;
                  PrintMiGong();
            }
      } while (i!=0 && j!=0);
}
void MiGong::CopyMiGong()//拷贝迷宫地图
{
      for (int i=0; i<M+2; i++)
            for (int j=0; j<N+2; j++)
                  c_map[i][j] = map[i][j];
}

void MiGong::PrintMiGong()//输出迷宫地图
{
      for (int i=0; i<M+2; i++)
      {
            for (int j=0; j<N+2; j++)
            {
                  if (i==0 || i==M+1 || j==0 || j==N+1)
                  {
                        if (map[i][j] < 10)
                              cout << 0;
                        cout << map[i][j];
                  }
                  else if (OPEN == map[i][j])
                        cout << ' ' << ' ';
                  else
                        cout << '#' << '#';
            }
            cout << endl;
      }
}
void MiGong::PrintWay() //输出路径
{
      for (int i=0; i<M+2; i++)
      {
            for (int j=0; j<N+2; j++)
            {
                  if (i==0 || i==M+1 || j==0 || j==N+1)
                  {
                        if (c_map[i][j] < 10)
                              cout << 0;
                        cout << c_map[i][j];
                  }
                  else if (ROAD == c_map[i][j])
                        cout << char(2) << char(2);
                  else if (OPEN == c_map[i][j])
                        cout << ' ' << ' ';
                  else
                        cout << '#' << '#';
            }
            cout << endl;
      }
}

bool MiGong::SearchWay()//寻找路径
{
      CopyMiGong();

      int front = 0; //队首
      int rear = 0;  //队尾
      bool find = false; //判断是否找到路径

      way[0].x = begin[0];
      way[0].y = begin[1];
      c_map[way[0].x][way[0].y] = PASSED; //该点已走过

      while (front<=rear && !find)
      {
            for (int i=0; i<4; i++)//判断当前路径点四周是否可通过
            {
                  int x = way[front].x + zx[i];
                  int y = way[front].y + zy[i];

                  if (c_map[x][y] == OPEN)//如果某个方向可通过，将该点纳入队列
                  {
                        rear++;
                        way[rear].x = x;
                        way[rear].y = y;
                        way[rear].pre = front;
                        c_map[x][y] = PASSED;
                  }
                  if (IsEnd(x, y)) //找到出口
                  {
                        PutWay(rear);
                        find = true;
                  }
            }
            front++;
      }
      return find;
}
void MiGong::PutWay(int rear) //输出路径
{
      CopyMiGong();

      int i = rear;
      do {
            c_map[way[i].x][way[i].y] = ROAD;
            i = way[i].pre;
      } while (!IsBegin(way[i].x, way[i].y));

      c_map[begin[0]][begin[1]] = ROAD;
}

int main()
{
      MiGong obj;
      char choice;

      do{
            obj.BuildMiGong();
            obj.PrintMiGong();
            cout << "对迷宫地图还满意吗？选择此迷宫输入y，重新选择迷宫输入n, 修改迷宫输入x" << endl;
            do{
                  cin >> choice;
            } while (choice != 'y' && choice != 'n' && choice != 'x');
      } while (choice == 'n');

      if (choice == 'x') //修正迷宫地图
            obj.PerfectMiGong();

      obj.GetBegin();  //创建入口坐标
      obj.GetEnd();  //创建出口坐标

      if (obj.SearchWay()) //如果找到迷宫路径
            obj.PrintWay(); //输出路径
      else
            cout << "此路不通！" << endl;

      getchar();getchar();
      return 0;
}

还可以用A*,模拟退火，遗传，蚂蚁这些算法，都是很有趣的搜索算法。