迷宫问题c语言 迷宫问题c语言课程设计目标

C语言基础知识总结大全

for( int i=0;i<4;i++){

C语言基础知识总结大全如下：

迷宫问题c语言 迷宫问题c语言课程设计目标

迷宫问题c语言 迷宫问题c语言课程设计目标

1、入门程序

2、数据类型

数据类型:

1.基本数据类型：

1.1. 整型:int 4个字节

1.2. 字符型:char 1个字节

1.3. 实型(浮点型)

1.3.1.单精度型:float 4个字节

1.3.2.双精度型:double 8个字节

2.构造类型：

2.1.枚举类型

2.2.数组类型

2.3.结构体类型

2.4.共用体类型

3.指针类型：

4.空类型：

3.格式化输出语句

%d:十进制整数;

%c:单个字符;

%s:字符串;

%f:6位小数;

4.常量

值不发生改变的量成为常量;

定义字符常量(注意后面没有;)

5.运算符

5.1.算数运算符:+,-,,/,%,++,--;前++/--,先运算,再取值.后++/--,先取值,再运算;

5.2.赋值运算符:

5.3.关系运算符;

5.4.逻辑运算符;

5.5.三目运算符:

表达式1 ? 表达式2 : 表达式3;

6.水仙花数计算

输出所有三位数的水仙花数字

所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数，如：153就是一个水仙花数，153=111+555+333。

7.打印正三角形的

8.臭名远扬的goto语句

很少使用

9.形参与实参

形参:形参是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数;

实参:实参是在调用时传递该函数的参数。

函数的形参和实参具有以下特点：

形参只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值等办法使实参获得确定值。

在参数传递时，实参和形参在数量上，类型上，顺序上应严格一致，否则会发生类型不匹配”的错误。

10.函数返回值注意

注意：void函数中可以有执行代码块，但是不能有返回值，另void函数中如果有return语句，该语句只能起到结束函数运行的功能。其格式为：return;

11.递归

12.变量存储类别 !

12.1.生存周期划分存储方式

C语言根据变量的生存周期来划分，可以分为静态存储方式和动态存储方式。

静态存储方式：是指在程序运行期间分配固定的存储空间的方式。静态存储区中存放了在整个程序执行过程中都存在的变量，如全局变量。

动态存储方式：是指在程序运行期间根据需要进行动态的分配存储空间的方式。动态存储区中存放的变量是根据程序运行的需要而建立和释放的，通常包括：函数形式参数；自动变量；函数调用时的现场保护和返回地址等。

用关键字auto定义的变量为自动变量，auto可以省略，auto不写则隐含定为“自动存储类别”，属于动int main()态存储方式。

用static修饰的为静态变量，如果定义在函数内部的，称之为静态局部变量；如果定义在函数外部，称之为静态外部变量。

注意：静态局部变量属于静态存储类别，在静态存储区内分配存储单元，在程序整个运行期间都不释放；静态局部变量在编译时赋初值，即只赋初值一次；如果在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值0（对数值型变量）或空字符（对字符变量）

为了提高效率，C语言允许将局部变量的值放在CPU中的寄存器中，这种变量叫“寄存器变量”，用关键字register作声明。

注意：只有局部自动变量和形式参数可以作为寄存器变量；一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量；局部静态变量不能定义为寄存器变量。

用extern声明的的变量是外部变量，外部变量的意义是某函数可以调用在该函数之后定义的变量。

13.内部函数外部函数 !

在C语言中不能被其他源文件调用的函数称为内部函数 ，内部函数由static关键字来定义，因此又被称为静态函数，形式为：

static [数据类型] 函数名（[参数]）

这里的static是对函数的作用范围的一个限定，限定该函数只能在其所处的源文件中使用，因此在不同文件中出现相同的函数名称的内部函数是没有问题的。

在C语言中能被其他源文件调用的函数称为外部函数 ，外部函数由extern关键字来定义，形式为：

extern [数据类型] 函数名([参数])

C语言规定，在没有指定函数的作用范围时，系统会默认认为是外部函数，因此当需要定义外部函数时extern也可以省略。 extern可以省略; 14.数组 数组:一块连续的，大小固定并且里面的数据类型一致的内存空间， 数组的声明:数据类型 数组名称[长度n]

数据类型 数组名称[长度n] = {元素1,元素2,元素3,......};

数据类型 数组名称[] = {元素1,元素2,元素3,......};

数类类型 数组名称[长度n]; 数组名称[0] = 元素1;数组名称[1] = 元素2;...... 注意： 1、数组的下标均以0开始；

2、数组在初始化的时候，数组内元素的个数不能大于声明的数组长度。

3、如果采用种初始化方式，元素个数小于数组的长度时，多余的数组元素初始化为0； 4、在声明数组后没有进行初始化的时候，静态（static）和外部（extern）类型的数组元素初始化元素为0，自动（auto）类型的数组的元素初始化值不确定。

15.数组遍历

数组的冒泡排序

冒泡排序的思想：相邻元素两两比较，将较大的数字放在后面，直到将所有数字全部排序。

字符串与数组

在C语言中,是没有办法直接定义子字符串数据类型的,需使用数组来定义所要的字符串,形式如下:

char 字符串名称[长度] = "字符串内容";

char 字符串名称[长度] = {'字符串1','字符串2',....,'字符串n','0'};

[]中的长度可以省略不写;

采用第二种方式一个元素必须是'0',表示结束;

第二种方式不能写中文!; 输出字符串时,要使用:printf("%s",字符数组名);或puts(字符数组名);

16.字符串函数

strlen(s):获取字符串s的长度;

strcmp(s1,s2):比较字符串;比较的时候会把字符串转换成ASCII码再进行比较,返回结果为0表示s1和s2的ASCII码值相等,返回结果为1表示s1比s2的ASCII码大,返回结果为-1表示s1比s2的ACSII码小;

strcpy(s1,s2):字符串拷贝;s2会取代s1中的内容;

strcat(s1,s2)将s2拼接到s1后面;注意:s1的length要足够才可以!

atoi(s1)将字符串转为整数!

17.数组

数据类型 数组名称[常量表达式1]...[常量表达式n];

数组的初始化与一维数组的初始化类似也是分两种：

数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n] = {{值1,..,值n},{值1,..,值n},...,{值1,..,值n}};

数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n]; 数组名称[下标1][下标2]...[下标n] = 值;

数组初始化要注意以下事项：

采用种始化时数组声明必须指定列的维数。因为系统会根据数组中元素的总个数来分配空间，当知道元素总个数以及列的维数后，会直接计算出行的维数；

采用第二种初始化时数组声明必须同时指定行和列的维数。

18.度数组的遍历

使用嵌套循环

注意:数组的每一维下标均不能越界!

19.结构体

C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。

结构用于表示一条记录，设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：

Title

Author

Subject

Book ID

定义结构

为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：

tag 是结构体标签。

member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。

variable-list 结构变量，定义在结构的末尾，一个分号之前，您可以指定一个或多个结构变量。下面是声明 Book 结构的方式：

在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：

访问结构成员

为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间//当前位置可通则返回TURE,否则返回FALSE的一个句号。您可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法：

20.共用体

共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。

21.指针

22.文件读写

写入文件

读取文件

C语言与C++学习路线

23.排序算法

十大经典排序算法(动态演示+代码)

24.查找算法

九种查找算法

C语言与C++面试知识总结

26.字符串作

字符串作的全面总结

27. C语言常用标准库解读

C语言常用标准库解读

28. C语言最常用的贪心算法

C语言最常用的贪心算法就这么被攻克了

29. 常见的C语言内存错误及对策

常见的C语言内存错误及对策

30. C语言实现面向对象的原理

C语言实现面向对象的原理

31. C语言/C++内存管理

看完这篇你还能不懂C语言/C++内存管理？

32. 再谈C语言指针

再谈指针：大佬给你拨开 C 指针的云雾

C语言函数指针之回调函数

C语言指针详解(文末有)

33. C语言预处理命令

长文详解：C语言预处理命令

34. C语言高效编程与代码优化

C语言高效编程与代码优化

35. C语言结构体

C语言之结构体就这样被攻克了！值得收藏！

36. 原码, 反码, 补码 详解

原码, 反码, 补码 详解

37. C语言宏定义

简述C语言宏定义的使用

38. c语言之共用体union、枚举、大小端模式

c语言之共用体union、枚举、大小端模式

C 语言可以零基础入门，它的语法是很多高级编程语言的基础，比如说 Ja、C++；并且起到承上启下的作用，向上可以学习高级编程语言，向下可以学习计算机组成原理、作系统等等偏基础的计算机基础知识。

书籍

本书《阿哈C语言》的写书风格个人认为比较风趣幽默，对于培养兴趣，基础学习还是很不错的

《C程序设计语言》，机械工业出版社，作者Brian W. Kernighan / （美）Dennis M. Ritchie。C 语言之父写的，入门经典书籍。

《C Primer Plus》 ，邮电出版社，作者 Stephen Prata。 可以作为 C 语言工具书，也可以作为入门，内容循序渐进，能够锻炼编程思想。

《C和指针》 深入了解指针，看完以后对指针不再害怕。

《C陷阱与缺陷》 正如书上所说，“本书所揭示的知识，至少能够帮助你减少 C 代码和初级 C++ 代码中 90% 的 Bug”，看完后可以避免 C 语言开发的一些坑。

网课

1、《郝斌C语言自学教程》

2、《程序设计入门——C语言》（浙大翁恺）

小项目

包括C语言迷宫、24点游戏、奔跑的火柴人、超市管理系统、打字母、电子时钟、对对碰、方块、黑白棋、华容道、火车票订票管理源码、连连看、商品销售系统、象棋、超级玛丽、图书管理系统、学生成绩管理系统。

用栈的方法设计迷宫求解（c语言）。。限时

exit(OVERFLOW);

#include"stdio.h"

exit(OVERFLOW); //初始化错误

#define M 6

#define N 8

#define MAX 100

typedef struct

{ int x;

int y;

};

typedef struct

{ int x,y,d;

}sanyuan;

typedef struct

{ sanyuan elem[MAX];

int top;

}sqstack;

void Initstack(sqstack s)

{s->top=-1;}

int stackempty(sqstack s)

{if(s->top==-1) return 1;

else return 0;}

void push(sqstack s,sanyuan e)

{if(s->top==MAX-1)

{printf("stack is fulln");

return;}for (i=0;i

s->top++;s->elem[s->top]=e;}

sanyuan pop(sqstack s,sanyuan e)

{e=s->elem[s->top];

s->top--;

return e;

}void printpath(sqstack s)

{sanyuan temp;

printf("(%d,%d)<==",M,N);

while(!stackempty(s))

{temp=pop(s,temp);

printf("(%d,%d)<==",temp.x,temp.y);

}printf("n");

}int mazepath()

{int maze[M+2][N+2]={{1,1,1,1,1,1,1,1,1,1},{1,0,1,1,1,0,1,1,1,1},{1,1,0,1,0,1,1,1,1,1},{1,0,1,0,0,0,0,0,1,1},{1,0,1,1,1,0,1,1,1,1},{1,1,0,0,1,1,0,0,0,1},{1,0,1,1,0,0,1,1,0,1},{1,1,1,1,1,1,1,1,1,1}};

move[8]={{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};

sqstack s;sanyuan temp;

int x,y,d,i,j;

Initstack(s);

temp.x=1;temp.y=1;temp.d=-1;

push(s,temp);

while(!stackempty(s))

{pop(s,temp);

x=temp.x;y=temp.y;d=temp.d+1;

while(d<8)

{i=x+move[d].x;

j=y+move[d].y;

if(maze[i][j]==0)

{temp.x=x;temp.y=y;temp.d=d;

push(s,temp);

x=i;y=j;

maze[x][y]=-1;

return 1;

}else d=0;

}else d++;

}}

return 0;

{mazepath();

}

关于C语言的问题,高手进

case 3:cout<<"龘";

#include 如果

void output(int,int);

#include

#include

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define OVERFLOW -2

#define IN99v_SIZE 100 //存储空间初始分配量

#define INCREMENT 30 //存储空间分配增量

#define MAXLEN 100//迷宫包括外墙行列数目

typedef struct{ //迷宫中row行col列的位置

int row;

int col;

}PostType;

typedef struct{

int ord; //当前位置在路径上的序号

PostType seat;//当前坐标

int di; //往下一坐标的方向

}SElemType; //栈元素类型

typedef struct{

SElemType base;//栈基址,构造前销毁后为空

SElemType top;//栈顶

int stackSize; //栈容量

}Stack; //栈类型

Status InitStack(Stack &S){ //构造空栈s

S.base=(SElemType)malloc(IN99v_SIZE sizeof(SElemType));

if(!S.base)

exit(OVERFLOW);//存储分配失败 OK;

}//InitStack

Status StackEmpty(Stack S){

//若s为空返回TRUE,否则返回 TRUE;

return FALSE;

}//StackEmpty

Status Push(Stack &S,SElemType e){

//插入元素e为新的栈顶元素 >=S.stackSize){//栈满，加空间

S.base=(SElemType )realloc(S.base,(S.stackSize+INCREMENT)sizeof(SElemType));

if(!S.base)

exit(OVERFLOW); //存储分配失败} OK;

}//push

Status Pop(Stack &S,SElemType &e){//若栈不空删除栈//顶元素用e返回并返回OK，否则返回 OK;

}//Pop

Status DestroyStack(Stack &S){//销毁栈 OK;

}//DestroyStack..

typedef struct{

int row;

int col;

char adr[MAXLEN][MAXLEN];//可取' ''001' '002' '#'

}MazeType; //迷宫类型

Status InitMaze(MazeType &maze){

//初始化迷宫若成功返回TRUE,否则返回FALSE

int m,n,i,j;

maze.row=0;

maze.col=0;

while(maze.row>50 || maze.row<5){

printf("请输入所要创建迷宫的行数:");

scanf("%d",&maze.row); //迷宫行数

if(maze.row>=50 || maze.row<=5)

printf("行数必须是5-50之间的整数n");

continue;

if(maze.row<=50 && maze.row>=5)

break;}

while(maze.col>50 || maze.col<5){

printf("请输入所要创建迷宫的列数:");

scanf("%d",&maze.col);

if(maze.col>=50 || maze.col<=5)

printf("列数必须是5-50之间的整数n");

continue;

if(maze.col<=50 && maze.col>=5)

break;}

for(i=0;i<=maze.col+1;i++){//迷宫行外墙

maze.adr[0][i]='#';

maze.adr[maze.row+1][i]='#';}//for

for(i=0;i<=maze.row+1;i++){//迷宫列外墙

maze.adr[i][0]='#';

maze.adr[i][maze.col+1]='#';}

for(i=1;i<=maze.row;i++)

for(j=1;j<=maze.col;j++)

maze.adr[i][j]=' ';//初始化迷宫

printf("下面请输入你的障碍坐标n注：当设置好障碍坐标后，输入数字0 后结束。");

do{ printf("n请输入障碍的横坐标: ");

scanf("%d",&m);

if(m==0)break;

if(m>maze.row){

printf("输入的数不能超过行数n");

continue;}

if(m<0){

printf("输入的数不能比1小n");

continue;}

printf("请输入障碍的纵坐标: ");

scanf("%d",&n);

if(n==0)break;

if(n>maze.col){

printf("输入的数不能超过列数n");

continue;}

if(n<0){

printf("输入的数不能比1小n");

continue;}

maze.adr[m][n]='#';//迷宫障碍用'#'标记

}while(m!=0||n!=0);//while

return OK;

}//InitMaze

Status Pass(MazeType maze,PostType cur){

if(maze.adr[cur.row][cur.col]==' ')//可通

return TRUE;

else

return FALSE;

}//Pass

Status FootPrint(MazeType &maze,PostType cur){

//若走过并且可通返回TRUE,否则返回FALSE

//在返回之前销毁栈S

maze.adr[cur.row][cur.col]='001';//"001"表示可通

return OK;

}//FootPrint

PostType NextPos(PostType &cur,int i){

//指示并返回下一位置的坐标

PostType c;

c=cur;

switch(i){ //1.2.3.4分别表示东,南,西,北方向

case 1 : c.col+=1; break;

case 2 : c.row+=1; break;

case 3 : c.col-=1; break;

case 4 : c.row-=1; break;

default: exit(ERROR);}

return c;

}//Next

Status MarkPrint(MazeType &maze,PostType cur){

//曾走过但不是通路标记并返回OK

maze.adr[cur.row][cur.col]='002';//"002"表示曾走过但不通

return OK;

}//MarkPrint

Status MazePath(MazeType &maze,PostType start,PostType _end){

//若迷宫maze存在从入口start到_end的通道则求得一条存放在栈中

//并返回TRUE,否则返回FALSE

Stack S;

PostType cur;

int curstep;//当前序号,1.2.3.4分别表示东,南,西,北方向

SElemType e;

InitStack(S);

cur=start; //设置"当前位置"为"入口位置"

curstep=1; //探索步

do{

if(Pass(maze,cur)){//当前位置可以通过,

//即是未曾走到过的通道

FootPrint(maze,cur);//留下足迹

e.ord=curstep;

e.seat=cur;

e.di=1;

Push(S,e); //加入路径

if(cur.row==_end.row&& cur.col==_end.col)

else

return TRUE; //到达出口

else{

cur=NextPos(cur,1);

//下一位置是当前位置的东邻

curstep++; //探索下一步

}//else

}//if

else{ //当前位置不通

if(!StackEmpty(S)){

Pop(S,e);

while(e.di==4

&& !StackEmpty(S)){

MarkPrint(maze,e.seat);

Pop(S,e);

//留下不能通过的标记,并退一步

}//while

if(e.di < 4){

Push(S,e);

//新方向上的相邻

}//if

}//if

}//else

}while(!StackEmpty(S));

else

return FALSE;

}//MazePath

void PrintMaze(MazeType &maze){

//将标记路径信息的迷宫输出到终端(包括外墙)

int i,j;

printf("n迷宫路径如下图所示:nn");

printf(" ");

for(i=0;i<=maze.col+1;i++)//打印列数名

printf("%4d",i);

printf("nn");

for(i=0;i<=maze.row+1;i++){

printf("%2d",i);//打印行名

for(j=0;j<=maze.col+1;j++)

printf("%4c",maze.adr[i][j]);//输出迷宫//当前位置的标记

printf("nn");

}}//PrintMaze

void main(){ //主函数

PostType start,_end;

char cmd;

do{ ("cls");

printf("##########################################################################n");

printf("# 迷宫求解 #n");

printf("# 姓名： 班级： 学号： #n");

printf("# 欢迎使用 copy left #n");

printf("##########################################################################n");

if(!InitMaze(maze)){ //初始化并创建迷宫

printf("nInitialization errors!!!n");

}do{ //输入迷宫入口坐标

printf("n输入迷宫入口坐标: ");

scanf("%d%d",&start.row,&start.col);

if(start.row>maze.row || start.row<1|| start.col>maze.col || start.col<1)

{ printf("n入口错误!!!n");

continue;}

}while(start.row>maze.row || start.row<1 || start.col>maze.col || start.col<1);

do{ //输入迷宫出口坐标

printf("n输入迷宫出口坐标: ");

scanf("%d%d",&_end.row,&_end.col);

if(_end.row>maze.row || _end.row<1 || _end.col>maze.col || _end.col<1){

printf("n出口错误!!!n");

continue;}

}while(_end.row>maze.row || _end.row<1 || _end.col>maze.col || _end.col<1);

if(!MazePath(maze,start,_end))//迷宫求解

printf("n此路不通!!!n");

else

PrintMaze(maze);//打印路径

printf("n如果继续请输入y，退出请输入n: ");

scanf("%s",&cmd);

}//main

迷宫求解问题用C＋＋编写.

1. 迷宫问题

/////////////////////////

/////////迷宫求解////////

/////时间:11.10.2006/////

/////////////////////////

//Migong.h

//利用栈进行回溯

/class:

Matrix:矩阵类

enum directions:四个方向

struct :搜索

Migong:迷宫类

1.创建一个Migong对象

2.使用用Create方法输入数据

3.使用Solve方法进行求解

4.ShowSolve方法显示解

5.可以重复使用Create方法

6.入口只能在左上角

7.默认出口在右下角

ShowAllPath:穷举所有的路径

备注:

由于算法原因,这里的所有路径应该是指

介于:

a.如果两条路存在某个点不同那么就是不同的路

b.如果在一条路中去掉一个或者一个以上的圈,那么他们是同一条路

之间意义上的路

/

#include

#include

#include

using namespace std;

#ifndef MIGONG_H

#define MIGONG_H

///////////////////

///////矩阵类//////

///////////////////

class Matrix{

int m;

int row, col;

bool iscreate;

public:

Matrix(){m=0;iscreate=false;};

~Matrix() {Release();};

bool Create(int, int);

int& operator () (int, int);

int GetRow(){return row;};

int GetCol(){return col;};

void Release();

void Show(char, char );

};

bool Matrix::Create(int r, int c)

{if( r<=0 || c<=0) return false;

Release();

row = r;

col = c;

m = new int[rowcol];

for (int i=0;i

{(m+i) = 0;

}iscreate = true;

}int& Matrix::operator ()(int r, int c)

{return (m+rcol+c);

}void Matrix::Release()

{if (iscreate)

{row = col = 0;

if (m) delete[] m;

m = 0;

}iscreate = false;

}void Matrix::Show(char blk='#', char nblk=' ')

{int i, j;

{for (j=0;j

{if ((m+icol+j) == 0)

cout<

else

cout<

}cout<

}}

/////////////////////////////

////迷宫相关数据结构的定义///

/////////////////////////////

struct offsets{

int a, b;

};

enum directions{

_S = 0,

_E,

_N,

_W

};

struct {

int row, col, dir;

};

class Migong{

static offsets move[4];

Matrix maze;

Matrix mark;

int row;

int desr;

int desc;

stack<> stk;

bool iscreate;

int pathlength;

bool GetPath();

bool IsInPath(int, int);

public:

Migong(){issolved=false;result=0;pathlength=row=col=0;iscreate=false;};

~Migong(){Release();};

bool Create(int , int , int , int , int );

void Solve();

void Release();

void OutputMaze();

void ShowSolve(char, char );

public:

bool issolved;

result;

};

offsets Migong::move[4]={ {1, 0}, {0, 1},

{-1, 0}, {0, -1}};

////////////////////////////

//迷宫数据应该是不含边框的//

////////////////////////////

bool Migong::Create(int m, int r, int c, int desrow=-1, int descol=-1)

{if (r<=0 || c<=0) return false;

Release();

if (desrow==-1 || descol==-1)

{desr = r;

desc = c;

}else

{desr = desrow;

desc = descol;

}row = r;

col = c;

maze.Create(r+2, c+2);

for (i=0;i

{for (j=0;j

{if (j==0 || j==c+1 || i==0 || i==r+1)

{mark(i, j) = maze(i, j) = 1;

}else

{mark(i, j) = 0;

maze(i, j) = m[((i-1)col+j-1)];

}}

}return iscreate = true;

}bool Migong::GetPath()

temp;

temp.col = 1;

temp.row = 1;

temp.dir = _S;

stk.push(temp);

while (!stk.empty())

{temp = i = temp.row;

int j = temp.col;

int d = temp.dir;

while (d<4)

{//根据当前点的状态确定下一个搜索点

int g = i + move[d].a;

int h = j + move[d].b;

if (g==desr && h==desc)

{return true;

}//如果这个点不是障碍点且没有被搜索过那么可以对这个点进行搜索

if (maze(g, h)==0 && mark(g, h)==0)

{mark(g, h) = 1;

temp.row = g;

temp.col = h;

temp.dir = d+1;

stk.push(temp);

i = g;

j = h;

d = _S;//对一下个点进行搜索

}else d++;

}}

return false;

}void Migong::Solve()

{issolved = GetPath();

if (issolved)

{pathlength = stk.size();

result = new [pathlength];

for (int i=0;i

{(result+i) = cout<<"("<<((result+i)).row<<","<<((result+i)).col<<")"<

}}

while (!stk.empty())

stk.pop();

}void Migong::Release()

{if (iscreate)

{maze.Release();

mark.Release();

row=col=0;

if (result)

delete [] result;

result = 0;

while (!stk.empty())

stk.pop();

}iscreate = false;

issolved = false;

pathlength = 0;

}void Migong::OutputMaze()

{if (!iscreate) return;

maze.Show();

}bool Migong::IsInPath(int r, int c)

{if (!iscreate || !issolved)

return false;

temp;

for (int i=0;i

{temp = (result+i);

if ((temp.row==r) && (temp.col==c))

}return false;

}void Migong::ShowSolve(char blk='#',char s='o')

{if (!iscreate) return;

if (!issolved)

{cout<<"无解"<

}else

{int i, j;

for (i=0;i

{for (j=0;j

{if ((i==1 && j==1) || (i==desr && j==desc))

{cout<

}else if (maze(i, j) == 1)

{cout<

}else

{if (IsInPath(i, j))

cout<

else

cout<<' ';

}}

}}

}//////////////////////

//////穷举所有路径////

//////////////////////

offsets move[4]={ {1, 0}, {0, 1},

{-1, 0}, {0, -1}};

struct node

{int row,col;

};

vector path;

int count;

bool IsReachable( Matrix& maze, Matrix& mark, node beg, node des)

{if (beg.row==des.row&&beg.col==des.col)

{//如果达到的话那么显示路径

count++;

cout<<"第"<

for (int i=0;i

cout<<"("<

cout<<"("<

return false;

}if (maze(beg.row, beg.col)==1 || mark(beg.row, beg.col)==1)

{return false;

}path.push_back(beg);

mark(beg.row, beg.col) = 1;

node nextnode;

for (int i=_S;i<_W+1;i++)

{nextnode.row = beg.row + move[i].a;

nextnode.col = beg.col + move[i].b;

}path.resize(path.size()-1);

mark(beg.row, beg.col) = 0;

return false;//如果不是穷举的话应该根据for循环的结果重新设置返回值

}/

参数maze,mark为迷宫长宽均加二的矩阵

desr,desc为出口点

/

void FindAllPath( Matrix& maze, Matrix& mark, int desr, int desc)

{node first, last;

first.row = 1;

first.col = 1;

last.row = desr;

last.col = desc;

IsReachable(maze, mark, first, last);

path.clear();

}/

m迷宫矩阵数据

r,c行和列的大小

desr,desc目标位置

/

void ShowAllPath(int m, int r, int c, int desr=-1, int desc=-1)

{Matrix maze, mark;

maze.Create(r+2, c+2);

if (desr==-1 || desc==-1)

{desr = r;

desc = c;

}int i, j;

for (i=0;i

{for (j=0;j

{if (j==0 || j==c+1 || i==0 || i==r+1)

{mark(i, j) = maze(i, j) = 1;

}else{

mark(i, j) = 0;

maze(i, j) = m[((i-1)c+j-1)];

}}

}count = 0;

FindAllPath(maze, mark, desr, desc);

maze.Release();

mark.Release();

}#endif

//main.cpp

#include

#include "Migong.h"

using namespace std;

int mg[]={

0,0,1,0,0,0,1,0,//1

0,0,1,0,0,0,1,0,//2

0,0,0,0,1,1,0,1,//3

0,1,1,1,0,0,1,0,//4

0,0,0,1,0,0,0,0,//5

0,1,0,0,0,0,0,1,//6

0,1,1,1,1,0,0,1,//7

1,1,0,0,0,1,0,1,//8

1,1,0,0,0,0,0,0,//9

};

void main()

{Migong m;

m.Create(mg, 9, 8);

m.OutputMaze();

m.Solve();

m.ShowSolve();

ShowAllPath(mg,9,8,9,8);

}2.任意两点的最短路

class Matrix

{bool IsCreated;

int data;

int row;

public:

Matrix(){IsCreated = false;row = 0; col = 0; data = 0;};

~Matrix(){if (data!=0) delete [] data;};

bool Create(int r, int c, int n);

int& operator () (int r, int c);

};

bool Matrix::Create(int r, int c, int n = 0)

{if ( IsCreated)

return false;

if ( (row = r) <=0 || (col = c) <=0)

return false;

data = new int[rowcol];

int i,j;

for (j=0;j

data[icol+j] = n;

IsCreated = true;

}int& Matrix::operator()(int r, int c)

}jingdian//Matrix类,存储点

dist//Matrix类,存储任意两点间的距离

MAX_DIST//一个大数,大于任意两点间的距离,当两点间没有路的时候设为它

bestdist//Matrix类,存储任意两点的最近距离

bestpath//Matrix类,i到j的最短路为i.......bestpath(i,bestpath(i,pbestpath(i,j))), bestpath(i,pbestpath(i,j)), j bestpath(i,j)表示i到j的最短路中j的前一个结点号

void GetBestPath()

{int n = jingdian.size();

int i, j, k;

bestdist.Create(n, n);

bestpath.Create(n, n);

for (i=0;i

for (j=0;j

{if ( (bestdist(i,j) = dist(i,j)) == -1)

bestdist(i,j) = MAX_DIST;

if ( i!=j && bestdist(i,j)

bestpath(i,j) = i;

else

bestpath(i,j) = -1;

}for (k=0;k

for (i=0;i

for (j=0;j

if (bestdist(i,k)+bestdist(k,j) < bestdist(i,j))

{bestdist(i,j) = bestdist(i,k)+bestdist(k,j);

bestpath(i,j) = bestpath(k,j);

}}

c语言迷宫小游戏，10乘10大小的迷宫，我拿别人的代码修改的，为什么结果总是显示找不到路径，代码如下

k=0;

这个代码太多，明显是不会看的节奏，但是我可以}void main()给出我的一个简化的方案或者说是一个思路

首先这明显是个搜索题：

我到了一个迷宫的一个点 它有上下左右四个方向可以去走吧，

所以简便方法 ：：先定义int x[4] ={0, 0, -1, +1};

int y[4]={1, -1, 0, 0};

我走迷宫肯定要标记的吧，不然我来回走不是永远也走不玩么;

所以我定义一个数组 int is_walk_by[row][colum];

3.然后我25.面试知识开始走了

bool zoulu( int a, int b){

//判断走对了的方法，再来个剪枝

主体

xx= a+x[i];

yy= b+x[i];

mark[xx][yy]=1;//设已经走过

if(zoulu(xx, yy)){

}else {

mark[xx][yy]=0;//还原

return false;

}}

//这好像是个递归深搜的方法，看看对你有没有用吧，没用当我没说

C语言中->是什么意思啊？

{printpath(s);

“->”是一个整体，它是用于指向结构体子数据的指针，用来取子数据。

MazeType maze;

换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”。

问题中的p=p->next ，意思是将p指向的一个结构体实例中的自数据next赋值给p。

扩展资料：

在C语言中，结构体(struct)指的是一种数据结构，是C语言中聚合数据类型(aggregate data type)的一类。结构体可以被声明为变量、指针或数组等，用以实现较复杂的数据结构。结构体同时也是一些元素的，这些元素称为结构体的成员(member)，且这些成员可以为不同的类型，成员一般用名字访问。

定义与声明：

结构体的定义如下所示，struct为结构体关键字，tag为结构体的标志，member-list为结构体成员列表，其必须列出其所有成员；variable-list为此结构体声明的变量。

->是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”.

举个例子：

struct Data

{int a,b,c;

}; /定义结构体/

struct Data p;/定义结构体指针/

struct Data A = {1,2,3};/声明变量A/

int x;/声明一个变量x/

p = &A ; /让p指向A/

x = p->a;/这句话的意思就是取出p所指向的结构体中包含的数据项a赋值给x/

/由于此时p指向A，因而 p->a == A.a,也就是1/

对于一开始的问题 p = p->next;这应该出现在C语言的链表，这里的next应该是一个与p同类型的结构体指针，其定义格式应该是：

struct Data

{int a;

struct Data next;

};/定义结构体/

…………

main()

……

p = p->next;/将next中的值赋给p/

}链表指针是C语言的一个难点，但也是重点，学懂了非常有用。要仔细讲就必须先讲变量、指针。

什么是变量？所谓变量，不要浅显的认为会变得量就是变量。套用我们的问话：“教室变不变？”变，因为每天有不同的人在里面上课，但又不变，因为教室始终在那，没有变大或变小。这就是变量：有一个不变的地址和一块可变的存储空间。正常情况下，我们只看到变量这个房间里面的东西，也就是其内容，但不会关注变量的地址，但是C语言的指针，就是这个房间的地址。我们声明变量就相当于盖了间房子存放东西，我们可以直接观看房子里的东西，而声明指针，就是相当于获得了一个，当用指针指向某个变量时，就是用指针给变量定位，以后我们就可以用指针找到他所“跟踪”的变量并可以获得里面的内容。

那结构体呢？结构体就相当于是有好几个房子组成的别墅，几个房子绑定在一起使用。设现在有很多这种别墅分布在一个大迷宫里，每间别墅里都有一间房子。里面放了另一个别墅的位置信息，现在你手拿找到了栋别墅，从里面得到了你想要的东西（链表的数据部分）,然后把下一栋别墅的位置计入你的（p = p->next），再走向下一栋别墅……如此走下去，知道走到某地下一栋别墅信息没有了（p->next == NULL），你的旅行结束。这就是链表一次遍历的过程。现在你能明白 p=p->next的含义了吧！

写了这么多。希望你能明白。

如果想学好c和C++，链表和指针必须熟练掌握！

->是一个整体，代表“指向”的意思。

例如有定义

struct

{int b;

struct next;

}c，d，p;

在上面的定义中,c和d是变量，它们的类型是，p是一个指向类型的指针变量。

p=&c;

则把变量c的地址赋给p，search_map(a,point_x-1,point_y);此时，p指向c。

p->next=d;

则d就是c的后继，此时p指向c，p->指向d，

p=p->next ；

则p就指向了d

->是一个整体，表示从指针访问结构体的成员变量

p = p->next

这常常用于结构体单链表，表示p指向下一个

->是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”.

struct Data p;/声明指针变量p/

……

p = p->next;/将next中的值赋给p/

->运算是间接寻址,你用多指针的话会发现指针用->这种调用方式更简洁

链表指针是C语言的一个难点，但也是重点，学懂了非常有用。要仔细讲就必须先讲变量、指针。

什么是变量?所谓变量，不要浅显的认为会变得量就是变量。举个例子:“教室变不变?”变，因为每天有不同的人在里面上课，但又不变，因为教室始终在那，没有变大或变小。这就是变量:有一个不变的地址和一块可变的存储空间。正常情况下，我们只看到变量这个房间里面的东西，也就是其内容，但不会关注变量的地址，但是C语言的指针，就是这个房间的地址。我们声明变量就相当于盖了间房子存放东西，我们可以直接观看房子里的东西，而声明指针，就是相当于获得了一个，当用指针指向某个变量时，就是用指针给变量定位，以后我们就可以用指针找到他所“跟踪”的变量并可以获得里面的内容。

至于我们写代码的结构体就相当于是有好几个房子组成的别墅，几个房子绑定在一起使用。设现在有很多这种别墅分布在一个大迷宫里，每间别墅里都有一间房子。里面放了另一个别墅的位置信息，现在你手拿找到了栋别墅，从里面得到了你想要的东西(链表的数据部分),然后把下一栋别墅的位置计入你的(p

=p->next)，再走向下一栋别墅……如此走下去，知道走到某地下一栋别墅信息没有了(p->next

==

NULL)，你的旅行结束。这就是链表一次遍历的过程。

aTdPage[ucTdPageIndex]->OnInit

();就相当于一个

叫问号表达式

原型：

表达式1 ? 表达式2 : 表达式3

意思判断表达式1否真真则执行表达式2否则执行表达式3

例：

max = (a > b ? a : b);

句意思ab较数赋值给max

->就是一个整体，p=p->next表示一个结构体变量p的成员next

p->next就是p结点的下一个结点的指针。

c语言程序设计 迷宫问题

C语言中存储类别又分为四类：自动（auto）、静态（static）、寄存器的（register）和外部的（extern） ;

#includeint i, j;

#include

#include

struct stack

{int v;

int i;

int j;

}s[1024];

void getmaze(int,int);

int takelmaze(int,int);

void push(int,int,int);

int maze[1024][1024];

bool mark[1024][1024];

int top;

{int n,m;

printf("请输入迷宫的大小?(n,m)n");

scanf("%d%d",&n,&m);

getmaze(n,m);

if(takelmaze(n,m))

output(n,m);

printf("输入回车离开程序。");

fflush(stdin);

while(getchar()!='n');

return 0;

}int takelmaze(int n,int m)

{int v;

int g,h;

int move[9][2]={{0,0},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};

v=1;

g=1;

top=0;

memset(mark,0,sizeof(mark));

mark[1][1]=1;

do{

g=move[v][0]+g;

h=move[v][1]+h;

if(g==n&&h==m&&maze[n][m]==0)

return 1;

if((maze[g][h]==0)&&(mark[g][h]==0))

{mark[g][h]=1;

push(g,h,v);

v=1;

}else if(v<8)

{g=-move[v][0]+g;

h=-move[v][1]+h;

v++;

}else

{if(top>0)

{g=s[--top].i;

h=s[--top].j;

v=s[--top].v;

v++;

}}

}while((top>=0)&&(v!=8));

printf("此迷宫无解n");

return 0;

}void getmaze(int n,int m)

{int a,b;

for(a=0;a<=n+1;a++)

{maze[a][0]=1;

maze[a][m+1]=1;

}for(b=0;b<=m+1;b++)

maze[n+1][b]=1;

}for(a=1;a<=n;a++)

{for(b=1;b<=m;b++)

scanf("%d",&maze[a][b]);

}return;

}void push(int i,int j,int v)

{s[top].i=i;

s[top].j=j;

s[top].v=v;

top++;

return;cout<

}void output(int n,int m)

{int i=0;

printf("(1,1)->");

while(i

printf("(%d,%d)-〉",s[i].i,s[i++].j);

return;

}

C/C++语言 “走出迷宫”

注:

#include

#include

#include

#include

using namespace std;

char a[100e.di++;//换下一个方向探索000][010000];

int u[5]={0,1,0,-1,0},

int b[100000],c[100000],p[100000],x,y,s=0,h,t,sx,sy;

void out(int d)

{s++;

if(p[d]!=0)out(p[d]);

return;

}int main()

{int n,m;h=0;t=1;

cin>>n>>m;

for(int i=1;i<=n;++i)

for(int j=1;j<=m;++j)

{c12.2.存储类型划分in>>a[i][j];

if(a[i][j]=='S')

{b[t]=i;c[t]=j;a[i][j]='#';

}if(a[i][j]=='T')

}}

while(h!=t)

{h++;

for(int i=1;i<=4;++i)

{x=b[h]+u[i];y=c[h]+w[i];

if(x>=1&&x<=n&&y>=1&&y<=m&&a[x][y]!='#')

{t++;

b[t]=x;c[t]=y;p[t]=h;a[x][y]='#';

if(x==sx&&y==sy)

{out(t);

cout<

}}

}}

}

如果你学过，用bfs，如果没学过，学习一下，你就会了，如果单要，╯﹏╰，伸手很令人的

数据结构 c语言 课程设计 小鼠走迷宫问题

{sx=i;sy=j;

1、可以用“”来代表老鼠，“|”来代表墙，空格来代表路。每走一步用("cls")刷新一次屏幕//////作者:baihacker/////。

2、墙不可穿过代表，墙与周围的格子没有边。

3、规定一个时间t，若在t步之内没有走到粮仓，则输出无解。

4、这个简单，无非就是修改条件，从而修改整{return data[rcol+c];个图。

5、所用路径可以用深搜（回朔）来解决，最短路就用广搜来解决。最短路也可以用Dijstra算法、floyd算法等，但广搜是最简单的。

具体的程序你自己实现吧，如果写不出来，就去请教一下你们学校的ACMer，他们应该会比较熟悉。加油吧。

请问你还保存着吗？

本人大一，急需大神指导，怎样用C语言做一个简单的迷宫，就是用和空格表示的那种，急求！！！

cur=NextPos(e.seat,e.di);//设定当前位置是该

#include

#include

#include

#include

#include

using namespace std;

typedef struct

{int x;

int y;

}Pos;

const int height=25;

const int weight=25;

stack s;

bool MazePath(int map[height][weight],int m,int n);

int map[25][25];

int z1, z2;

void printmap();

void makemap();

void makeway(int,int);

int searchPath(int, int);

{for(int i=0; i<=23 ;++i)

for(int j=0; j<=23; ++j)

map[i][j] = 1;

makemap();

cout << "典型的迷宫测试" <

if (!MazePath(map,0,0))

{cout<<"无路可走"<

return 0;

}Pos p;

while(!s.empty())

{}makeway(10,4);

makeway(10,5);

printmap();

("pause");

return 0;

}bool MazePath(int map[height][weight],int m,int n)

{Pos p={m,n};

s.push(p);

if (map[m][n]==-2)

else if (map[m][n]==1||map[m][n]==2)

{s.pop();

return false;

}else if(map[m][n]==0)

map[m][n]=2;

if (n+1

if (m+1

if (n-1>=0&&MazePath(map,m,n-1))

if(m-1>=0&&MazePath(map,m-1,n))

s.pop();

return false;

}void printmap()

{for(z2=1; z2<=23; z2++)

{for(z1=1;z1printf("(%d,%d)",n,m);<=23;z1++) {

switch(map[z2][z1])

{case -1:cout<<"入";

break;

case -2:cout<<"出";

break;

case 0:cout<<" ";

break;

case 1:cout<<"■";

break;

case 2:cout<<"XX";

break;

break;

case 4{struct Data p;/声明指针变量p/:cout<<"②";

break;

case 5:cout<<"①";

break;

}}

}cout << endl;

}void makemap()

{for(z1=0, z2=24; z1<=24; ++z1)

{map[z1][0] = 0;

map[z1][z2] = 0;

}for(z1=0, z2=24; z1<=24; ++z1)

{map[0][z1] = 0;

map[z2][z1] = 0;

}map[2][1] = -1;

map[22][23] = -2;

srand((unsigned)time(NULL));

searchPath(rand()%11+1, rand()%11+1);

}int searchPath(int x, int y)

{static int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};

int zx = x2;

int zy = y2;

int next, turn, i;

map[zx][zy] = 0;

turn = rand()%2 ? 1 : 3;

for(i=0, next=rand()%4; i<4; ++i, next=(next+turn)%4)

if(map[zx+2dir[next][0]][zy+2dir[next][1]] == 1)

{map[zx+dir[next][0]][zy+dir[next][1]] = 0;

searchPath(x+dir[next][0], y+dir[next][1]);

}return 0;

}void makeway(int count,int a)

{int hcout=0;

while (hcout

{z1=rand()%21+2;

z2=rand()%21+2;

if (map[z1][z2+1]!=a&&map[z1][z2+1]!=a&&map[z1+1][z2]!=a&&map[z1-1][z2]!=a&&map[z1][z2]!=3)

{map[z1][z2]=a;

hcout++;

}}

}/本迷宫 地图每次都是随机生成，且生成图形每次都不一样，在生成的基础上，加上了自动寻路功能。电脑的思维方式体现在了迷宫的路径上。电脑走过的正确的道路用龘表示，错误的道路用XX表示。没有走过的道路为空白的。其中①和②为各类陷阱，本迷宫只有一条出路~/

这个是我大一时候做的设计，现在可能忘记很多了，我是直接般过来的。当初我做了3天！