c語言數字迷宮
Ⅰ 隨即產生50個1-50之間的不重復的數用c語言如何編寫程序
#include <stdio.h>
#include <stdlib.h>
#define M 50
int main()
{
int x[M],i,k;
srand(time(NULL));/*要先設置種子*/
for(i=0;i<M;i++)
{
x[i]=1+rand()%48; /*這樣只做告能得到1..48之間的數,修改x[i]=1+rand()%50;*/
for(k=i-1;k>=0;k--)
{
if(x[i]=x[k]) /*比較要用if(x[i] == x[k])*/
{
i--;
break;
}
}
}
for(i=0;i<M;i++)
printf("x[%d]=%d\n",i,x[i]);
return 0;
}
換一種思路：先將1..50排好,然後隨機交換50次，效率比較高
#include <stdio.h>銷迅
#include <純斗明stdlib.h>
#define M 50
int main()
{
int x[M],k;
int tmp;
for(i=0;i<M;i++) x[i]=i+1;/*順序賦值*/
srand(time(NULL));/*設置種子，這個很重要，不然每次運行，結果都相同*/
for(i=0;i<50;i++)
{
k = rand()%50;/*產生一個0..49的隨機數*/
tmp = x[k];x[k]=x[i];x[i]=tmp;/*交換x[i],x[k]*/
}
for(i=0;i<M;i++) printf("x[%d]=%d\n",i,x[i]);
return 0;
}
Ⅱ 數據結構迷宮問題（c語言）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXLEN 10//迷宮包括外牆最大行列數目
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
#define STACK_INIT_SIZE 100 //存儲空間初始分配量
typedef struct{
int r,c;
} PosType;//迷宮中r行c列的位置
typedef struct MazeType{
int r;
int c;
char arr[MAXLEN][MAXLEN];//可取' ''*' '@' '#'
}MazeType; //迷宮類型
typedef struct{
int step; // 當前位置在路徑上的「序號」
PosType seat; //當前的坐標位置
int di; //往下一坐標位置的方向
}SElemType;
typedef struct NodeType{
SElemType data;
NodeType *next;
}NodeType,*LinkType;//結點類型
typedef struct SqStack{
LinkType top;
int stacksize;
}SqStack; //棧類型
PosType start;
PosType end;
MazeType maze;
bool found;
Status InitStack(SqStack &S){
S.top=(LinkType)malloc(sizeof(NodeType));
S.top->next=NULL;
S.stacksize=0;
return OK;
}//InitStack;
Status Push(SqStack &S,SElemType &e){
LinkType p;
p=(NodeType*)malloc(sizeof(NodeType));
if(!p) return ERROR;
p->data=e;
p->next=S.top;
S.top=p;
S.stacksize++;
//S.top=S.base+S.stacksize;
//S.top->data=e;
return OK;
}//Push
Status StackEmpty(SqStack S){
if(S.top->next==NULL) return OK;
return ERROR;
}//StackEmpty
Status Pop(SqStack &S,SElemType &e){
LinkType p;
if(StackEmpty(S)) return ERROR;
p=S.top;
e=p->data;
S.top=S.top->next;
S.stacksize--;
free(p);
return OK;
// 棧頂元素出棧
}//Pop
Status DestroyStack(SqStack &S){//銷毀棧S,
LinkType p;
while(S.top!=NULL){
p=S.top;
S.top=S.top->next;
free(p);
}//while
if(S.top==NULL) return OK;
else return ERROR;
}//DestroyStack
Status MarkPrint(MazeType &maze,PosType curpos){
maze.arr[curpos.r][curpos.c]='@';//"@"表示曾走過但不通
return OK;
}//Markprint曾走過但不是通路標記並返回OK
Status FootPrint(MazeType &maze,PosType curpos){
maze.arr[curpos.r][curpos.c]='*';//"*"表示可通
return OK;
}//FootPrint
PosType NextPos(PosType &curpos,int i){
PosType cpos;
cpos=curpos;
switch(i){ //1.2.3.4分別表示東,南,西,北方向
case 1 : cpos.c+=1; break;
case 2 : cpos.r+=1; break;
case 3 : cpos.c-=1; break;
case 4 : cpos.r-=1; break;
default: exit(ERROR);
}//switch
return cpos;
}//Nextpos
Status Pass(MazeType &maze, PosType curpos){
/*for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
printf("%4c",maze.arr[i][j]);
}
printf("\n");
}*/
//char a=' ';
//printf("%4d",a);
//printf("%d,%d",curpos.r,curpos.c);
//printf("%4c",maze.arr[1][1]);
if(maze.arr[curpos.r][curpos.c]==' '){//當前位置可通
//printf("go");
return TRUE;
}//if
else{
//printf("go");
return FALSE;
}//else
}//Pass
void InitMaze(MazeType &maze, char a[MAXLEN][MAXLEN], int row, int col){
//printf("go");
maze.r=row;
maze.c=col;
//printf("%d,%d",row,col);
for(int i=0;i<=col+1;i++){a[0][i]='1';a[row+1][i]='1';}
//printf("go");
for(i=0;i<=row+1;i++){a[i][0]='1';a[i][col+1]='1';}
//printf("go");
/*for(i=0;i<10;i++){
for(int j=0;j<10;j++){
printf("%4c",a[i][j]);
}
printf("\n");
}
*/
for(i=0;i<=maze.r+2;i++){
for(int j=0;j<maze.c+2;j++){
if(a[i][j]=='1') maze.arr[i][j]='#';
//if(a[i][j]==0) maze.arr[i][j]=' ';
else maze.arr[i][j]=' ';
}//for
}//for
}//InitMaze
Status MazePath(MazeType &maze,PosType start,PosType end)
{//求解迷宮maze中，從入口start到出口end的一條路徑，
//若存在則返回TRUE,否則返回FALSE
PosType curpos;
int curstep;
SqStack S;
SElemType e;
InitStack(S);
curpos=start;//設定「當前位置」為「入口位置」
curstep=1; //探索第一步
found=false;
do{
if(Pass(maze,curpos))
{
//當前位置可以通過，即是未曾走到過的通道塊留下足跡
FootPrint(maze,curpos);//做可以通過的標識
e.step=curstep;
e.seat=curpos;
e.di=1;//為棧頂元素賦值
if(Push(S,e)!=OK) return ERROR;
if(curpos.r==end.r && curpos.c==end.c) found=true;//如果到達終點返回true
else{
curpos=NextPos(curpos,1);//下一位置是當前位置的東鄰
curstep++;//探索下一步
}//else
}//if
else
if(StackEmpty(S)!=1)
{
Pop(S,e);
while(e.di==4 && !StackEmpty(S))
{
MarkPrint(maze,e.seat);
Pop(S,e);
curstep--;
}//while
if(e.di<4)
{
e.di++;
Push(S,e);//換下個方向探索
curpos=NextPos(e.seat,e.di);
}//if
}//if
}while(StackEmpty(S)!=1&&!found);
DestroyStack(S);
if(found)
return true;
else
return false;//沒有找到路徑
}//MazePath
void PrintMaze(MazeType &maze){
//將標記路徑信息的迷宮輸出到終端(包括外牆)
for(int i=0;i<=maze.r+2;i++){
for(int j=0;j<=maze.c+2;j++){
printf("%4c",maze.arr[i][j]);//輸出迷宮
}//for
printf("\n");
}//for
}//PrintMaze
void Initialization(){
system("cls");
printf("********************************************************");
printf("\n*CreatMaze--c MazePath--m PrintMaze--p Quit--q*");
printf("\n********************************************************");
}//Initialization
void ReadCommand(char &cmd){
do{
if(cmd=='c'||cmd=='C'){
printf("\n********************************************************");
printf("\n*Enter a operation :m或M *");
printf("\n*退出--Enter a operation :q或Q *");
printf("\n********************************************************");
}//if
else if(cmd=='m'||cmd=='M'){
printf("\n********************************************************");
printf("\n*Enter a operation :p或P *");
printf("\n*退出--Enter a operation :q或Q *");
printf("\n********************************************************");
}//else if
else if(cmd=='0'){
printf("\n********************************************************");
printf("\n*Enter a operation :c或P *");
printf("\n*退出--Enter a operation :q或Q *");
printf("\n********************************************************");
}
printf("\n\n Operration:-");
cmd=getchar();
}while(!(cmd=='c'||cmd=='C'||cmd=='m'||cmd=='M'||cmd=='p'||cmd=='P'||cmd=='q'||cmd=='Q'));
}//ReadCommand
void Interpre(char cmd){
//MazeType maze;//開始的時候定義在這個地方，不是全局的，調用出現了問題。
//PosType start;//開始的時候定義在這個地方，不是全局的，調用出現了問題。
//PosType end;//開始的時候定義在這個地方，不是全局的，調用出現了問題。
switch(cmd){
case 'C':
case 'c':{
int rnum, cnum, i=0,m=1,n=1;
char a2[MAXLEN][MAXLEN];
char input[1];
char data[100000];
printf("\n請輸入迷宮數據文件名！\n");
//printf("go");
scanf("%s",input);
FILE *fp;
fp=fopen(input,"r");
//printf("go");
if(!fp){
printf("\n不能打開文件\n");
break;
}//if
//printf("go");
while(!feof(fp)){
fscanf(fp,"%s",&data[i]);
if(i==0){rnum=(int)data[i]-(int)'0';/*printf("%d",rnum);*/}
if(i==1){cnum=(int)data[i]-(int)'0';/*printf("%d",rnum);*/}
if(i>=2){
if(n>cnum){m++;n=1;}
a2[m][n]=data[i];
//printf("%d",a2[m][n]);
n++;
}//if
i++;
}//while
fclose(fp);
//printf("go");
InitMaze(maze, a2, rnum, cnum);
printf("\n迷宮建立完成！！\n");
//PrintMaze(maze);
break;
}//case
case 'M':
case 'm':{
printf("\n請輸入迷宮入口的坐標，以空格為間隔:--");
scanf("%d %d",&start.r,&start.c);
printf("\n請輸入迷宮出口的坐標，以空格為間隔:--");
scanf("%d %d",&end.r,&end.c);
//printf("%d,%d,%d,%d",start.r,start.c,end.r,end.c);
//PrintMaze(maze);
MazePath(maze, start, end);
//PrintMaze(maze);
break;
}//case
case 'P':
case 'p':{
if(found){
printf("\n求解迷宮的結果如下--\n");
PrintMaze(maze);
}//if
else{
printf("\n找不到路徑！\n");
}//else
}//case
}//switch
}//Interpre
void main(){
char cmd='0';
Initialization();
//cmd=getchar();
do{
ReadCommand(cmd);
Interpre(cmd);
}while(cmd!='q'&&cmd!='Q');
}//main
Ⅲ 用c++寫一個迷宮程序
#include<iostream>
using namespace std;
class T //定義描述迷宮中當前位置的結構類型
{
public:
int x; //x代表當前位置的行坐標
int y; //y代表當前位置的列坐標
int dir; //0:無效,1:東,2:南,3:西,4:北
};
class LinkNode //鏈表結點
{
friend class Stack;
public:
T data;
LinkNode *next;
};
class Stack
{
private:
LinkNode *top; //指向第一個結點的棧頂指針
public:
Stack(); //構造函數，置空棧
~Stack(); //析構函數
void Push(T e); //把元素data壓入棧中
T Pop(); //使棧頂元素出棧
T GetPop(); //取出棧困蔽頂元素
void Clear(); //把棧清空
bool empty(); //判斷棧是否為空，如果為空則返回1，否則返回0
};
Stack::Stack() //構造函數，置空棧
{
top=NULL;
}
Stack::~Stack() //析構函昌友數汪迅州
{
}
void Stack::Push(T e) //把元素x壓入棧中
{
LinkNode *P;
P=new LinkNode;
P->data=e;
P->next=top;
top=P;
}
T Stack::Pop() //使棧頂元素出棧
{
T Temp;
LinkNode *P;
P=top;
top=top->next;
Temp=P->data;
delete P;
return Temp;
}
T Stack::GetPop() //取出棧頂元素
{
return top->data;
}
void Stack::Clear() //把棧清空
{
top=NULL;
}
bool Stack::empty() //判斷棧是否為空，如果為空則返回1，否則返回0
{
if(top==NULL) return 1;
else return 0;
}
int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}}; //定義當前位置移動的4個方向
bool Mazepath(int **maze,int m,int n);
//尋找迷宮maze中從（0，0）到（m,n）的路徑
//到則返回true,否則返回false
void PrintPath(Stack p); //輸出迷宮的路徑
void Restore(int **maze,int m,int n); //恢復迷宮
int** GetMaze(int &m,int &n); //獲取迷宮
//返回存取迷宮的二維指針
int main()
{
int m=0,n=0; //定義迷宮的長和寬
int **maze; //定義二維指針存取迷宮
maze=GetMaze(m,n); //調用GetMaze(int &m,int &n)函數，得到迷宮
if(Mazepath(maze,m,n)) //調用Mazepath(int **maze,int m,int n)函數獲取路徑
cout<<"迷宮路徑探索成功!\n";
else cout<<"路徑不存在!\n";
return 0;
}
int** GetMaze(int &m,int &n)//返回存取迷宮的二維指針
{
int **maze; //定義二維指針存取迷宮
int i=0,j=0;
cout<<"請輸入迷宮的長和寬:";
int a,b;cin>>a>>b; //輸入迷宮的長和寬
cout<<"請輸入迷宮內容:\n";
m=a;
n=b; //m,n分別代表迷宮的行數和列數
maze=new int *[m+2]; //申請長度等於行數加2的二級指針
for(i= 0;i<m+2;i++) //申請每個二維指針的空間
{
maze[i]=new int[n+2];
}
for(i=1;i<=m;i++) //輸入迷宮的內容，0代表可通，1代表不通
for(j=1;j<=n;j++)
cin>>maze[i][j];
for(i=0;i<m+2;i++)
maze[i][0]=maze[i][n+1]=1;
for(i=0;i<n+2;i++)
maze[0][i]=maze[m+1][i]=1;
return maze; //返回存貯迷宮的二維指針maze
};
bool Mazepath(int **maze,int m,int n)//尋找迷宮maze中從（0，0）到（m,n）的路徑
//到則返回true,否則返回false
{
Stack q,p; //定義棧p、q,分別存探索迷宮的過程和存儲路徑
T Temp1,Temp2;
int x,y,loop;
Temp1.x=1;
Temp1.y=1;
q.Push(Temp1); //將入口位置入棧
p.Push(Temp1);
maze[1][1]=-1; //標志入口位置已到達過
while(!q.empty()) //棧q非空，則反復探索
{
Temp2=q.GetPop(); //獲取棧頂元素
if(!(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y))
p.Push(Temp2);
//如果有新位置入棧，則把上一個探索的位置存入棧p
for(loop=0;loop<4;loop++) //探索當前位置的4個相鄰位置
{
x=Temp2.x+move[loop][0]; //計算出新位置x位置值
y=Temp2.y+move[loop][1]; //計算出新位置y位置值
if(maze[x][y]==0) //判斷新位置是否可達
{
Temp1.x=x;
Temp1.y=y;
maze[x][y]=-1; //標志新位置已到達過
q.Push(Temp1); //新位置入棧
}
if((x==(m))&&(y==(n))) //成功到達出口
{
Temp1.x=m;
Temp1.y=n;
Temp1.dir=0;
p.Push(Temp1); //把最後一個位置入棧
PrintPath(p); //輸出路徑
Restore(maze,m,n); //恢復路徑
return 1; //表示成功找到路徑
}
}
if(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y)
//如果沒有新位置入棧，則返回到上一個位置
{
p.Pop();
q.Pop();
}
}
return 0; //表示查找失敗，即迷宮無路經
}
void PrintPath(Stack p) //輸出路徑
{
cout<<"迷宮的路徑為\n";
cout<<"括弧內的內容分別表示為(行坐標,列坐標,數字化方向,方向)\n";
Stack t; //定義一個棧，按從入口到出口存取路徑
int a,b;
T data;
LinkNode *temp;
temp=new LinkNode; //申請空間
temp->data=p.Pop(); //取棧p的頂點元素，即第一個位置
t.Push(temp->data); //第一個位置入棧t
delete temp; //釋放空間
while(!p.empty()) //棧p非空，則反復轉移
{
temp=new LinkNode;
temp->data=p.Pop(); //獲取下一個位置
//得到行走方向
a=t.GetPop().x-temp->data.x; //行坐標方向
b=t.GetPop().y-temp->data.y; //列坐標方向
if(a==1) temp->data.dir=1; //方向向下，用1表示
else if(b==1) temp->data.dir=2; //方向向右，用2表示
else if(a==-1) temp->data.dir=3; //方向向上，用3表示
else if(b==-1) temp->data.dir=4; //方向向左，用4表示
t.Push(temp->data); //把新位置入棧
delete temp;
}
//輸出路徑，包括行坐標，列坐標，下一個位置方向
while(!t.empty()) //棧非空，繼續輸出
{
data=t.Pop();
cout<<'('<<data.x<<','<<data.y<<','<<data.dir<<","; //輸出行坐標，列坐標
switch(data.dir) //輸出相應的方向
{
case 1:cout<<"↓)\n";break;
case 2:cout<<"→)\n";break;
case 3:cout<<"↑)\n";break;
case 4:cout<<"←)\n";break;
case 0:cout<<")\n";break;
}
}
}
void Restore(int **maze,int m,int n) //恢復迷宮
{
int i,j;
for(i=0;i<m+2;i++) //遍歷指針
for(j=0;j<n+2;j++)
{
if(maze[i][j]==-1) //恢復探索過位置，即把-1恢復為0
maze[i][j]=0;
}
}
示例輸出：
測試1：
請輸入迷宮的長和寬:5 5
請輸入迷宮內容:
0 1 1 0 0
0 0 1 1 0
1 0 0 1 1
1 0 0 1 0
1 1 0 0 0
迷宮的路徑為
括弧內的內容分別表示為(行坐標,列坐標,數字化方向,方向)
(1,1,1,↓)
(2,1,2,→)
(2,2,1,↓)
(3,2,1,↓)
(4,2,2,→)
(4,3,1,↓)
(5,3,2,→)
(5,4,2,→)
(5,5,0,)
迷宮路徑探索成功!
測試2：
請輸入迷宮的長和寬:9 8
請輸入迷宮內容:
0 0 1 0 0 0 1 0
0 0 1 0 0 0 1 0
0 0 0 0 1 1 0 1
0 1 1 1 0 0 1 0
0 0 0 1 0 0 0 0
0 1 0 0 0 1 0 1
0 1 1 1 1 0 0 1
1 1 0 0 0 1 0 1
1 1 0 0 0 0 0 0
迷宮的路徑為
括弧內的內容分別表示為(行坐標,列坐標,數字化方向,方向)
(1,1,1,↓)
(2,1,1,↓)
(3,1,1,↓)
(4,1,1,↓)
(5,1,2,→)
(5,2,2,→)
(5,3,1,↓)
(6,3,2,→)
(6,4,2,→)
(6,5,3,↑)
(5,5,2,→)
(5,6,2,→)
(5,7,1,↓)
(6,7,1,↓)
(7,7,1,↓)
(8,7,1,↓)
(9,7,2,→)
(9,8,0,)
迷宮路徑探索成功!
Ⅳ 數據結構演算法（c語言） 迷宮求解
注釋非常詳細，希望對你有所幫助。
#include<stdio.h>
#include<stdlib.h>
#define M 15
#define N 15
struct mark //定義迷宮內點的坐標類型
{
int x;
int y;
};
struct Element //"戀"棧元素，嘿嘿。。
{
int x,y; //x行,y列
int d; //d下一步的方向
};
typedef struct LStack //鏈棧
{
Element elem;
struct LStack *next;
}*PLStack;
/*************棧函數****************/
int InitStack(PLStack &S)//構造空棧
{
S=NULL;
return 1;
}
int StackEmpty(PLStack S)//判斷棧是否為空
{
if(S==NULL)
return 1;
else
return 0;
}
int Push(PLStack &S, Element e)//壓入新數據元素
{
PLStack p;
p=(PLStack)malloc(sizeof(LStack));
p->elem=e;
p->next=S;
S=p;
return 1;
}
int Pop(PLStack &S,Element &e) //棧頂元素出棧
{
PLStack p;
if(!StackEmpty(S))
{
e=S->elem;
p=S;
S=S->next;
free(p);
return 1;
}
else
return 0;
}
/***************求迷宮路徑函數***********************/
void MazePath(struct mark start,struct mark end,int maze[M][N],int diradd[4][2])
{
int i,j,d;int a,b;
Element elem,e;
PLStack S1, S2;
InitStack(S1);
InitStack(S2);
maze[start.x][start.y]=2; //入口點作上標記
elem.x=start.x;
elem.y=start.y;
elem.d=-1; //開始為-1
Push(S1,elem);
while(!StackEmpty(S1)) //棧不為空 有路徑可走
{
Pop(S1,elem);
i=elem.x;
j=elem.y;
d=elem.d+1; //下一個方向
while(d<4) //試探東南西北各個方向
{
a=i+diradd[d][0];
b=j+diradd[d][1];
if(a==end.x && b==end.y && maze[a][b]==0) //如果到了出口
{
elem.x=i;
elem.y=j;
elem.d=d;
Push(S1,elem);
elem.x=a;
elem.y=b;
elem.d=886; //方向輸出為-1 判斷是否到了出口
Push(S1,elem);
printf("\n0=東 1=南 2=西 3=北 886為則走出迷宮\n\n通路為:(行坐標,列坐標,方向)\n");
while(S1) //逆置序列 並輸出迷宮路徑序列
{
Pop(S1,e);
Push(S2,e);
}
while(S2)
{
Pop(S2,e);
printf("-->(%d,%d,%d)",e.x,e.y,e.d);
}
return; //跳出兩層循環，本來用break,但發現出錯，exit又會結束程序，選用return還是不錯滴
}
if(maze[a][b]==0) //找到可以前進的非出口的點
{
maze[a][b]=2; //標記走過此點
elem.x=i;
elem.y=j;
elem.d=d;
Push(S1,elem); //當前位置入棧
i=a; //下一點轉化為當前點
j=b;
d=-1;
}
d++;
}
}
printf("沒有找到可以走出此迷宮的路徑\n");
}
/*************建立迷宮*******************/
void initmaze(int maze[M][N])
{
int i,j;
int m,n; //迷宮行,列 [/M]
printf("請輸入迷宮的行數 m=");
scanf("%d",&m);
printf("請輸入迷宮的列數 n=");
scanf("%d",&n);
printf("\n請輸入迷宮的各行各列:\n用空格隔開,0代表路,1代表牆\n",m,n);
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
scanf("%d",&maze[i][j]);
printf("你建立的迷宮為(最外圈為牆)...\n");
for(i=0;i<=m+1;i++) //加一圈圍牆
{
maze[i][0]=1;
maze[i][n+1]=1;
}
for(j=0;j<=n+1;j++)
{
maze[0][j]=1;
maze[m+1][j]=1;
}
for(i=0;i<=m+1;i++) //輸出迷宮
{
for(j=0;j<=n+1;j++)
printf("%d ",maze[i][j]);
printf("\n");
}
}
void main()
{
int sto[M][N];
struct mark start,end; //start,end入口和出口的坐標
int add[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//行增量和列增量 方向依次為東西南北 [/M]
initmaze(sto);//建立迷宮
printf("輸入入口的橫坐標,縱坐標[逗號隔開]\n");
scanf("%d,%d",&start.x,&start.y);
printf("輸入出口的橫坐標,縱坐標[逗號隔開]\n");
scanf("%d,%d",&end.x,&end.y);
MazePath(start,end,sto,add); //find path
system("PAUSE");
}
測試數據，演算法復雜度你就自己來寫吧，如果你連這都不自己做，那你一定是在應付作業。勸你還是自己運行測試一下吧，免得答辯時老師問你，什麼都不知道，那你就悲劇了。祝你好運！！
Ⅳ C語言數據結構 老鼠走迷宮問題
/* 迷宮矩陣
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 1 0 0 0 1
1 1 1 0 0 1 0 1 0 1
1 0 0 0 1 0 0 0 0 1
1 0 0 0 0 1 0 1 0 1
1 1 0 1 0 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1
1 1 0 0 0 1 0 0 0 1
1 1 1 1 1 1 1 1 1 1
*/
#include<stdio.h>
#define m 7
#define n 8
void path()
{
int maze[m+2][n+2] ;
int move[4][2]={ {0,-1},{-1,0},{0,1},{1,0} };
int s[54][3];
int top=0;
int i,j,k,f=0;
int g,h,p;
for(i=0;i<m+2;++i)
for(j=0;j<n+2;++j)
scanf("%d",&maze[i][j]);
maze[1][1]=2;
s[top][0]=1;
s[top][1]=1;
s[top][2]=0;
++top;
while(top!=0&&f==0)
{
--top;
i=s[top][0];
j=s[top][1];
k=s[top][2];
while(k<4)
{
g=i+move[k][0];
h=j+move[k][1];
if(g==m&&h==n&&maze[g][h]==0)
{
for(p=0;p<top;++p)
printf("%3d,%d\n",s[p][0],s[p][1]);
printf("%3d,%d\n",i,j);
printf("%3d,%d\n",m,n);
f=1;
}//if
if(maze[g][h]==0)
{
maze[g][h]=2;
s[top][0]=i;
s[top][1]=j;
s[top][2]=k;
++top;
i=g;
j=h;
k=0;
}//if
k=k+1;
}//while
}//while
if(f==0)
printf("no path\n");
}//pathvoid main()
{
path();
}
Ⅵ 數據結構迷宮問題，程序有錯，請問下面的程序應該怎麼修改，急！！！
php">#include<stdio.h>
#include物春<malloc.h>
#include<conio.h>
typedefstructpos/*描述迷宮當前位置和方向*/
{
intx;
inty;
intway;/*0:無效,1:左,2:下,3:右,4:上*/
}P;
typedefstructLinkNode/*鏈表結構,用於棧的元素類型*/
{
Ppos;
structLinkNode*next;
}LinkNode;
typedefstructstack/*鏈式棧,用於存儲迷宮路徑信息*/
{
LinkNode*head;/*頭指針*/
}Stack;
introw=0;/*迷宮的行數*/
intline=0;/*迷宮的列數*/
voidInitStack(Stack*s)/*棧置空*/
{
s->head=NULL;
}
voidPush(Stack*s,Pp)/*數據入棧*/
{
LinkNode*LN=(LinkNode*)malloc(sizeof(LinkNode));
LN->pos=p;
LN->next=s->head;
s->head=LN;
}
PPop(Stack*s)/*棧頂元素出棧*/
{
Ppos;
LinkNode*LN;
LN=s->head;
s->head=s->head->next;
pos=LN->pos;
deleteLN;
returnpos;
}
PGetPop(Stacks)/*讀取棧頂元素*/
{
returns.head->pos;
}
intEmpty(Stacks)/*判空*/
{
if(s.head==NULL)
return1;
else
return0;
}
int**InitMaze()/*返回迷宮的二維指針*/
{
int**maze=NULL;
inti;
intj;
printf("請輸入迷宮的告喚行跟列(x,y):");
scanf("%d,%d",&row,&line);/*輸入迷宮的行和列*/
maze=(int**)malloc((row+2)*sizeof(int*));
for(i=0;i<row+2;i++)
{
maze[i]=(int*)malloc(sizeof(int)*(line+2));
}
printf("請輸入迷宮 ");/*輸入迷宮,1代表路障,0代表通行*/
for(i=1;i<=row;i++)
for(j=1;j<=line;j++)
scanf("%d",&maze[i][j]);
for(i=0;i<line+2;i++)/*將迷宮的四周都變為1*/
maze[0][i]=1;
for(i=0;i<line+2;i++)
maze[row+1][i]=1;
for(i=0;i<row+2;i++)
maze[i][0]=1;
for(i=0;i<row+2;i++)
maze[i][line+1]=1;
for(i=0;i<row+2;i++)/*輸出迷宮*/
{
for(j=0;j<line+2;j++)
printf("%3d",maze[i][j]);
printf(" ");
}
罩友耐returnmaze;
}
voidPrintWay(Stackp)/*輸出路徑*/
{
Ppos;
Stackt;/*臨時棧,用於存儲從入口到出口的路徑*/
LinkNode*temp;
inta,b;
InitStack(&t);
temp=(LinkNode*)malloc(sizeof(LinkNode));
temp->pos=Pop(&p);/*取棧頂元素,即出口*/
Push(&t,temp->pos);/*入棧*/
free(temp);
while(!Empty(p))
{
temp=(LinkNode*)malloc(sizeof(LinkNode));
temp->pos=Pop(&p);/*獲取下一個元素*/
a=GetPop(t).x-temp->pos.x;/*左:a=0,b=1;下:a=1,b=0*/
b=GetPop(t).y-temp->pos.y;/*右:a=0,b=-1上:a=-1,b=0;*/
if(b==1)
temp->pos.way=1;
elseif(a==1)
temp->pos.way=2;
elseif(b==-1)
temp->pos.way=3;
elseif(a==-1)
temp->pos.way=4;
Push(&t,temp->pos);/*新位置入棧*/
free(temp);
}
printf("迷宮的路徑為: ");
printf("前兩個數字表示位置,最後一個數字表示方向 ");
printf("1表示向左,2表示向下,3表示向右,4表示向上,0表示無方向 ");
while(!Empty(t))/*輸出路徑*/
{
pos=Pop(&t);
printf("%3d,%3d,%3d ",pos.x,pos.y,pos.way);
}
}
intFindMaze(int**maze,intr,intl)/*尋找路徑,找到返回1,沒找到返回0*/
{
Stackp,q;/*棧p,q分別表示探索迷宮的路徑和過程*/
Ptemp1,temp2;
inta,b;
InitStack(&p);
InitStack(&q);
temp1.x=1;
temp1.y=1;//
maze[1][1]=-1;/*標記已經走過*/
Push(&p,temp1);
Push(&q,temp1);
while(!Empty(q))
{
temp2=GetPop(q);
if(!(GetPop(p).x==GetPop(q).x
&&GetPop(p).y==GetPop(q).y))
Push(&p,temp2);/*若有新元素入棧,就把q的棧頂元素存入p中*/
a=temp2.x;
b=temp2.y+1;/*當前位置左方向相鄰的方塊*/
if(maze[a][b]==0)
{
temp1.x=a;
temp1.y=b;
maze[a][b]=-1;/*標記已走過*/
Push(&q,temp1);
}
if(a==r&&b==l)/*到達出口*/
{
temp1.way=0;
Push(&p,temp1);
PrintWay(p);
return1;
}
a=temp2.x+1;
b=temp2.y;/*當前位置下方向相鄰的方塊*/
if(maze[a][b]==0)
{
temp1.x=a;
temp1.y=b;
maze[a][b]=-1;/*標記已走過*/
Push(&q,temp1);
}
if(a==r&&b==l)/*到達出口*/
{
temp1.way=0;
Push(&p,temp1);
PrintWay(p);
return1;
}
a=temp2.x;
b=temp2.y-1;/*當前位置右方向相鄰的方塊*/
if(maze[a][b]==0)
{
temp1.x=a;
temp1.y=b;
maze[a][b]=-1;/*標記已走過*/
Push(&q,temp1);
}
if(a==r&&b==l)/*到達出口*/
{
temp1.way=0;
Push(&p,temp1);
PrintWay(p);
return1;
}
a=temp2.x-1;
b=temp2.y;/*當前位置上方向相鄰的方塊*/
if(maze[a][b]==0)
{
temp1.x=a;
temp1.y=b;
maze[a][b]=-1;/*標記已走過*/
Push(&q,temp1);
}
if(a==r&&b==l)/*到達出口*/
{
temp1.way=0;
Push(&p,temp1);
PrintWay(p);
return1;
}
if(GetPop(p).x==GetPop(q).x
&&GetPop(p).y==GetPop(q).y)/*若四個方向都走不通,則數據出棧,退回一格*/
{
Pop(&p);
Pop(&q);
}
}
return0;/*探索迷宮失敗*/
}
voidmain()
{
int**maze=InitMaze();/*初始化迷宮*/
if(FindMaze(maze,row,line))/*探索路徑*/
printf("路徑探索成功! ");
else
printf("路徑探索失敗! ");
getch();
}
Ⅶ c語言，用二維數組解決迷宮問題。來段完整的代碼吧。
好的，以下是使用二維數組解決迷宮問題的C語言代碼示例：
Copy code
#include <stdio.h>
#define ROW 6 // 迷宮行數
#define COL 6 // 迷宮列數
int maze[ROW][COL] = { // 迷宮地圖 1表兄銀碰示障礙，0表示通路
{1, 1, 1, 1, 1, 1},
{1, 0, 0, 1, 0, 1},
{1, 0, 0, 1, 0, 1},
{1, 0, 0, 0, 0, 1},
{1, 0, 1, 1, 0, 1},
{1, 1, 1, 1, 1, 1},
};
int result[ROW][COL]; // 存放走迷宮的結果
int dfs(int row, int col) {
if (row == ROW - 1 && col == COL - 1) { // 到達終點
result[row][col] = 1;
return 1;
}
if (maze[row][col] == 0) { // 當前位置是通路
result[row][col] = 1;
if (row < ROW - 1 && dfs(row + 1, col)) { // 向下走有解
return 1;
}
if (col < COL - 1 && dfs(row, col + 1)) { // 向右走有解
return 1;
}
result[row][col] = 0; // 標記走過的路
}
return 0; // 返回無解羨談
}
void print_result() {
printf("走迷宮的結果：\n");
for (int i = 0; i < ROW; i++) {
for (int j = 0; j < COL; j++) {
printf("%d ", result[i][j]);
}
printf("\n");
}
}
int main() {
if (dfs(0, 0)) { // 從起點開始走迷宮
print_result();
} else {
printf("無法走出迷宮！\n");
}
return 0;
}
上述搏碰代碼中，我們使用了一個二維數組 maze 來表示迷宮地圖，其中 1 表示障礙，0 表示通路；另一個二維數組 result 用來存儲走迷宮的結果，其中 1 表示該位置走通了， 0 表示該位置沒有走通。
我們使用 dfs 函數來進行深度優先搜索，從起點 (0, 0) 開始往下、往右走，直到走到終點 (ROW-1, COL-1)，如果存在通路，則將路徑標記在 result 數組中，並返回 1，否則返回 0 表示無解。
最後，我們在 main 函數中調用 dfs 函數，判斷是否能從起點走出迷宮，如果有解，則輸出走迷宮的結果；否則，輸出 "無法走出迷宮" 的提示。