编程走迷宫创作背景目的和意义都是为了更好的学习编程。
1、背景：《数据结构》在软件工程中是一门综合性的专业基础课。数据结构的研究性不仅涉及到计算机硬件（特别是编码理论、储存装置和存取方法等）的研究范围，而且和计算机软件的研究有着更密切的关系，无论是编程还是 *** 作系统，都涉及到数据元素在存储器中的分配问题。
2、课程设计的目的和意义：目的是综合运用所学的数据结构知识完成对走迷宫的编程，达到加深对数据结构了解的目的，扩展数据结构方面的知识。意义是通过本次课程设计，可以培养独立思考、综合运用所学有关相应知识的能力，能更好的巩固java数据结构课程学习的内容，学会理论与实践相结合。掌握基本的分析问题和利用计算机求解问题，具备初步的高级语言程序设计能力，为以后的课程和毕业设计做好准备。
c#界面绘制的时候，底层重绘每次会清除画布背景，然后再全部重新绘制，这才是导致闪烁最主要的原因。于是重载消息发送函数 *** 作，禁掉这条消息。代码如下：
protected override void WndProc(ref Message m)
{
if (mMsg == 0x0014) // 禁掉清除背景消息
return;
baseWndProc(ref m);
}
不太明白楼主的思路，a[][]是迷宫数据吧，怎么还能修改了？
今天有了点时间，看了下，知道怎么回事了。
先就题论题，说下解决方案：把 if(a[c[k][0]][c[k][1]]==1)改成 if(a[c[k][0]+b[i][0]][c[k][1]+b[i][1]]==1)，有了解决方案，问题原因就很明白了，你应该是知道的，我不多说了。
然后再延伸下，说下楼主的算法：经过上面的修改后，程序是可以得到正确结果了，但那是因为这个迷宫比较简单，而不是因为算法是正确的，如果换一个稍微复杂点的迷宫，很可能它就又不会有输出了，下面详细说明，这是你原来的迷宫：
1,1,1,0,0,0
0,0,1,0,0,0
0,0,1,1,0,0
0,0,0,1,1,0
0,0,0,0,1,1
0,0,0,0,0,1
它只有一条路，而这条路是通的，所以你的算法可以顺利运行出结果，但是如果我把它修改成这样：
1,1,1,0,0,0
1,0,1,0,0,0
1,0,1,1,0,0
1,0,0,1,1,0
1,0,1,0,1,1
1,1,1,0,0,1
这样的迷宫里有两条路，一条是原来的那条通路，一条是死胡同，而你的算法会先去尝试那条死胡同，而且到了死胡同的尽头后会卡在最后两步来回重复，再也出不去了，这是你自己的算法，你自己应该能想明白，我就不说那么多了。
所以一个正确的算法应该去检测是否到了死胡同，如果是的话就应该沿原路回滚直到上次的岔路口，然后判断这个岔路口的每个分支是否都走过了，如果是就继续回滚到再上一次的岔路口，具体算法我现在没时间考虑了，你得靠自己了，如果实在不行可以给我留言，我有空再帮你想想。
这个迷宫的路径不是唯一的，因此从不同方向开始试探执行结果也可能会不唯一。我写的是参考书上的，共有八个方向可以试探。
栈解决迷宫主要的几个问题：
1迷宫的存储
2栈的设计
3试探方向
4不重复到达某点，即不陷入死循环
如果对算法有什么疑问，或是我的回答有错误的地方，可以Hi我。
#define LINES 9 // 定义行数
#define COLS 8 // 定义列数
#include <stdioh>
#include <stdlibh>
#include <malloch>
typedef struct{
int line;
int col;
}MOVE; // 定义试探方向的结构体
MOVE to[8] = {{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}}; // 定义数组，存放8个试探方向
typedef struct{ // 行、列、方向构成的三元组
int x;
int y;
int d;
}DataType;
typedef struct node{
DataType element;
struct node next;
}StackNode,LinkStack;
LinkStack InitStack(LinkStack s); // 栈初始化
LinkStack PushStack(LinkStack,DataType ); // 入栈函数
LinkStack PopStack(LinkStack,DataType ); // 出栈函数
int EmptyStack(LinkStack s); // 判定栈空
int path(int maze[][COLS+2]); // 打印路径
void printpath(LinkStack s,DataType t);
int main( void )
{
int i,j;
int maze[LINES+2][COLS+2] = // 定义存放迷宫的数组并初始化
{1,1,1,1,1,1,1,1,1,1,
1,0,0,1,0,0,0,1,0,1,
1,0,0,1,0,0,0,1,0,1,
1,0,0,0,0,1,1,0,1,1,
1,0,1,1,1,0,0,1,0,1,
1,0,0,0,1,0,0,0,0,1,
1,0,1,0,0,0,1,0,1,1,
1,0,1,1,1,1,0,0,1,1,
1,1,1,0,0,0,1,0,1,1,
1,1,1,0,0,0,0,0,0,1,
1,1,1,1,1,1,1,1,1,1
};
for(i=1;i<LINES+1;i++)
{
for(j=1;j<COLS+1;j++){
if( 0 == maze[i][j] ){
printf("□");
}
else{
printf("■");
}
}
printf("\n");
}
if( path(maze) ){
printf("找到一条路径\n");
for(i=1;i<LINES+1;i++)
{
for(j=1;j<COLS+1;j++)
{
if( 0 == maze[i][j] ){
printf("□");
}
else if( 1 == maze[i][j]){
printf("■");
}
else{
printf("☆");
}
}
printf("\n");
}
}
else{
printf("迷宫无路径\n");
}
return 0;
}
LinkStack InitStack(LinkStack s)
{
return NULL;
}
LinkStack PushStack(LinkStack s,DataType t)
{
StackNode p;
p = NULL;
p = (StackNode )malloc(sizeof(StackNode));
if(!p){
printf("申请结点失败\n");
exit(1);
}
p->element = t;
p->next = s;
s = p;
return s;
}
LinkStack PopStack(LinkStack s,DataType t)
{
StackNode p = NULL;
if( EmptyStack(s) ){
printf("栈空\n");
return NULL;
}
p = s;
t = p->element;
s = s->next;
free(p);
p = NULL;
return s;
}
int EmptyStack(LinkStack s)
{
if( NULL == s ){
return 1;
}
return 0;
}
int path(int maze[][COLS+2])
{
int i,j,x1,y1,v;
DataType temp;
LinkStack top;
tempx = 1;
tempy = 1;
tempd = -1;
top = InitStack(top);
top = PushStack(top,&temp);
while( !EmptyStack(top) )
{
top = PopStack(top,&temp);
// 入口为(1,1)，从0方向开始试探
x1 = tempx;
y1 = tempy;
v = tempd + 1;
while( v < 8 )
{
i = x1 + to[v]line;
j = y1 + to[v]col;
if( 0 == maze[i][j] ){ // 到达新点
tempx = x1;
tempy = y1;
tempd = v;
top = PushStack(top,&temp); // 坐标及方向入栈
x1 = i;
y1 = j;
maze[x1][y1] = -1; // 对已经到过的点做标记
if( x1 == LINES && y1 == COLS ){ // 到达出口
printpath(top,&temp); // 打印路径
return 1;
}
else{
v = 0;
}
}
else{
v++;
}
}
}
return 0;
}
void printpath(LinkStack s,DataType t)
{
while( !EmptyStack(s) )
{
printf("(%d, %d, %d)\n",s->elementx,s->elementy,s->elementd);
s = PopStack(s,t);
}
}
#include <stdioh>
#include <stdlibh>
#include <timeh>
/迷宫的数组/
int maze[100][100];
/迷宫的行数和列数/
int m=7,n=7;
/
对迷宫进行初始化，用随机数产生迷宫
/
void InitMaze()
{
int i,j,temp;
srand((unsigned)time(NULL));
for(i=1;i<=m;i++)
for(j=1;j<=n;j++)
{
temp=rand()%100;
if(temp>30)
{
maze[i-1][j-1]=0;
}else
{
maze[i-1][j-1]=1;
}
}
maze[0][0]=0;
maze[m-1][n-1]=9;
}
/
定义栈和栈的节点
/
typedef struct Node
{
int x;
int y;
struct Node next;
}Node,Stack;
/
初始化Stack
/
void InitStack(Node Stack)
{
Stack=(Node )malloc(sizeof(Node));
if(Stack==NULL)
{
printf("分配空间失败\n");
exit(0);
}else
{
Stack->next=NULL;
}
}
/
压栈
/
void push(Node Stack,int x,int y)
{
Node temp;
temp=(Node )malloc(sizeof(Node));
if (!temp)
{
printf("分配内存空间错误");
return;
}
else
{
temp->x=x;
temp->y=y;
temp->next=Stack->next;
Stack->next=temp;
}
}
/
出栈
/
void pop(Node Stack,int x,int y)
{
Node temp;
temp=Stack->next;
if(!temp){
return;
}else{
x=temp->x;
y=temp->y;
}
Stack->next=temp->next;
free(temp);
}
/
判断栈是否为空
/
int isEmpty(Node Stasck)
{
return ((Stasck->next)==NULL);
}
/
判断从该点时候可以向其他方向移动，并返回移动的方向
/
int pass(int i,int j)
{
/右方向/
if(j<n-1&&(maze[i][j+1]==0||maze[i][j+1]==9))
{
return 2;
}
/下方向/
if(i<m-1&&(maze[i+1][j]==0||maze[i+1][j]==9))
{
return 3;
}
/左方向/
if(j>=1&&(maze[i][j-1]==0||maze[i][j-1]==9))
{
return 4;
}
/上方向/
if(i>=1&&(maze[i-1][j]==0||maze[i-1][j]==9))
{
return 5;
}
return -1;
}
/
对迷宫进行打印
/
void printMaze()
{
int i=0,j=0;
printf(" ");
for(i=0;i<n;i++)
{
if(i+1>9)
printf("%d ",i+1);
else
printf(" %d",i+1);
}
printf("\n");
for(i=0;i<m;i++){
if(i+1>9)
printf("%d",i+1);
else
printf(" %d",i+1);
for(j=0;j<n;j++)
{
if(maze[i][j]==0||maze[i][j]==9||maze[i][j]==-1)
{
printf("a ");
}
else if(maze[i][j]==1)
{
printf("b ");
}else
if(maze[i][j]==2)
{
printf("D ");
}else if(maze[i][j]==3)
{
printf("X ");
}else if(maze[i][j]==4)
{
printf("A ");
}else if(maze[i][j]==5)
{
printf("W ");
}
}
printf("\n");
}
}
/
对迷宫进行路径搜索
数组的数字有以下含义
0该点没有被探索过，且可行
1该点不可行
2该点是可行的，且进行了向东的探索
3该点是可行的，且进行了向南的探索
4该点是可行的，且进行了向西的探索
5该点是可行的，且进行了向北的探索
6该点是入口
9该点是出口
-1该点已经遍历完毕四个方向，不能找到有效的路径，则置为－1
/
void FindPath()
{
int curx=0,cury=0;
int count=0;
int flag=0;
Node Stacks=NULL;
InitStack(Stacks);
do{
if(maze[curx][cury]==9)
{
flag=1;
}
switch(pass(curx,cury)){
case 2:
maze[curx][cury]=2;
push(Stacks,curx,cury);
cury++;
break;
case 3:
maze[curx][cury]=3;
push(Stacks,curx,cury);
curx++;
break;
case 4:
maze[curx][cury]=4;
push(Stacks,curx,cury);
cury--;
break;
case 5:
maze[curx][cury]=5;
push(Stacks,curx,cury);
curx--;
break;
case -1:
maze[curx][cury]=-1;
if(!isEmpty(Stacks))
pop(Stacks,&curx,&cury);
break;
}
count++;
}while(!isEmpty(Stacks)&&flag==0);
if(flag==1)
{
printf("该迷宫的行走路径如下:\n");
printMaze();
}else
{
printf("\nSorry,该迷宫无解\n");
}
}
/
主函数
要求输入m，n的值，要符合要求
程序打印出生成的迷宫，然后进行寻找路径
如果可以找到出口，则画出该路径
如果该迷宫没有出口，则提示迷宫无解
/
int main()
{
/printf("请输入迷宫的行数m(大于0，小于100):");
scanf("%d",&m);
printf("请输入迷宫的列数n(大于0，小于100):");
scanf("%d",&n);
if(m<0||m>100||n<0||n>100){
printf("输入数据错误,程序退出\n");
exit(-1);
}/
InitMaze();
printf("原迷宫为:\n");
printMaze();
FindPath();
getch();
return 0;
}
你好，
软糖花时间使用C#控制台做了个演示程序，见下图：
迷宫这个程序还是有些复杂的，初学者可能有点难懂。不懂再问吧。
一、定义结构 --> 点，表示坐标X和Y
public struct 点 {public 点(int vX, int vY) { X = vX; Y = vY; }
public int X { get; set; }
public int Y { get; set; }
}
二、定义抽象迷宫类，提供一个二维数组
public abstract class 迷宫 {internal int[,] _map;
internal 点 _起始点;
internal int _高;
internal int _宽;
public int[,] map {
get {
return _map;
}
}
public 点 originPos {
get {
return _起始点;
}
}
public int 高 {
get {
return _高;
}
}
public int 宽 {
get {
return _宽;
}
}
public abstract void 生成迷宫(int width, int height, 点 originPos);
}
三、定义阻挡墙和阻挡方向
[Flags]public enum 阻挡方向 {
无 = 0,
上 = 1,
下 = 2,
左 = 4,
右 = 8,
}
public class 迷宫墙 {
public 迷宫墙(int x, int y, 阻挡方向 方向) {
thisx = x;
thisy = y;
this阻挡方向 = 方向;
}
public int x;
public int y;
public 阻挡方向 阻挡方向;
}
四、迷宫程序 --> 输出到控制台
using System;namespace 迷宫生成 {
class Program {
static void Main(string[] args) {
var maze = new 普利姆迷宫();
ConsoleBackgroundColor = ConsoleColorWhite;
ConsoleForegroundColor = ConsoleColorBlack;
ConsoleWriteLine("生成迷宫 21 X 21 ");
ConsoleReadKey();
//重新开始生成迷宫
重新生成:
ConsoleCursorVisible = false;
ConsoleCursorLeft = 0;
ConsoleCursorTop = 1;
int startX = 9;
int startY = 9;
int 宽 = 21;
int 高 = 21;
ConsoleSetWindowSize(60, 30);
ConsoleSetWindowPosition(0, 0);
maze生成迷宫(宽, 高, new 点(startX, startY));
for (int y = 0; y < maze高; y++) {
for (int x = 0; x < maze宽; x++) {
var k = mazemap[y, x];
if (k == 0) {
//绘制墙
ConsoleBackgroundColor = ConsoleColorGray;
ConsoleWrite(" ");
} else {
//绘制通路
ConsoleBackgroundColor = ConsoleColorDarkCyan;
ConsoleWrite(" ");
}
}
ConsoleWriteLine();
}
//退出
ConsoleBackgroundColor = ConsoleColorBlack;
ConsoleWriteLine();
ConsoleBackgroundColor = ConsoleColorBlack;
ConsoleForegroundColor = ConsoleColorWhite;
ConsoleWriteLine("按空格键重新生成迷宫，其他任意键退出");
//绘制开始点
ConsoleCursorLeft = startX;
ConsoleCursorTop = startY + 1;
ConsoleBackgroundColor = ConsoleColorDarkGray;
ConsoleForegroundColor = ConsoleColorYellow;
ConsoleWrite("始");
var j = ConsoleReadKey();
if (jKey == ConsoleKeySpacebar) {
goto 重新生成;
}
}
}
}
具体有什么不懂的再问把，代码拿走~~慢慢研究把。
记得点赞、采纳、好评哟~~
#include <stdioh>
#include <iostream>
#include <conioh>
#include <windowsh>
#include <timeh>
using namespace std;
#define Height 25//高度，必须为奇数
#define Width 25 //宽度，必须为奇数
#define Wall 1 //用1表示墙
#define Road 0 //用0表示路
#define Start 2
#define End 3
#define up 72
#define down 80
#define left 75
#define right 78
#define flag 5
int map[Height+2][Width+2];
int x=2,y=1; //玩家当前位置，刚开始在入口处
class Migong
{
public:
void gotoxy(int x,int y); //移动坐标的函数声明
void shengcheng(int x,int y); //随机生成迷宫的函数声明
void display(int x,int y); //显示迷宫的函数声明
void chushi(); //初始化迷宫的函数声明
};
class Wanjia:public Migong //玩家类由迷宫类派生来
{
public:
void gonglue(int x,int y);
void shang(int x,int y);
void xia(int x,int y);
void zuo(int x,int y);
void you(int x,int y);
void game(); //游戏运行包括移动的函数声明
};
void Migong::gotoxy(int x,int y) //移动坐标 这是使光标 到（x，y）这个位置的函数调用 COORD 需要#include
{
COORD coord;
coordX=x;
coordY=y;
SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
}
void Migong::shengcheng(int x,int y) //随机生成迷宫
{
int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向 //数组c 0 1 向右
// 1 0 向下
// -1 0 向上
// 0 -1 向左
int i,j,t;
//将方向打乱
for(i=0;i<4;i++)
{
j=rand()%4; //随机生成j
t=c[i][0];c[i][0]=c[j][0];c[j][0]=t; //将c[i][0]和c[j][0]交换
t=c[i][1];c[i][1]=c[j][1];c[j][1]=t; //类似上
}
map[x][y]=Road; //当前位置设为路
for(i=0;i<4;i++) //沿四个方向设置
if(map[x+2c[i][0]][y+2c[i][1]]==Wall) //沿c[i][0]、c[i][1]方向前2步如果是墙
{
map[x+c[i][0]][y+c[i][1]]=Road; //让该方向前一步设为路
shengcheng(x+2c[i][0],y+2c[i][1]); //在该方向前两步继续生成地图 因为这里是递归函数，当执行到最后一点发现都不能走的时候，
//会返回到上一个函数，也就是上一个点，再次判断是否可以产生地图 ，知道地图上所有点被遍历完。
}
}
void Migong::display(int x,int y) //显示迷宫
{
gotoxy(2y-2,x-1);
switch(map[x][y])
{
case Start:
cout<<"入";break; //显示入口
case End:
cout<<"出";break; //显示出口
case Wall:
cout<<"■";break; //显示墙
case Road:
cout<<" ";break; //显示路
case up:
cout<<"↑";break; //在攻略中的标记 下同
case down:
cout<<"↓";break;
case left:
cout<<"←";break;
case right:
cout<<"→";break;
case flag:
cout<<" ";break; //标记，防止攻略遍历时候无线循环
}
}
void Migong::chushi()
{
int i,j;
srand((unsigned)time(NULL)); //初始化随机种子
for(i=0;i<=Height+1;i++)
for(j=0;j<=Width+1;j++)
if(i==0||i==Height+1||j==0||j==Width+1) //初始化迷宫 默认四周是路
map[i][j]=Road;
else map[i][j]=Wall;
shengcheng(2(rand()%(Height/2)+1),2(rand()%(Width/2)+1)); //从随机一个点开始生成迷宫，该点行列都为偶数
for(i=0;i<=Height+1;i++) //边界处理 把最开始默认为路的堵上,以免跑出迷宫
{
map[i][0]=Wall;
map[i][Width+1]=Wall;
}
for(j=0;j<=Width+1;j++) //边界处理
{
map[0][j]=Wall;
map[Height+1][j]=Wall;
}
map[2][1]=Start; //给定入口
map[Height-1][Width]=End; //给定出口
for(i=1;i<=Height;i++) //i初始为1,结束为height,以免画出外围
for(j=1;j<=Width;j++) //画出迷宫 同上
display(i,j);
}
void Wanjia::game()
{
int x=2,y=1; //玩家当前位置，刚开始在入口处
int c; //用来接收按键
while(1)
{
gotoxy(2y-2,x-1);
cout<<"☆"; //画出玩家当前位置
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(30,24); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
break;
c=getch();
}
if(c!=-32)
{
c=getch();
switch(c)
{
case 72: //向上走
if(map[x-1][y]!=Wall)
{
display(x,y);
x--;
}
break;
case 80: //向下走
if(map[x+1][y]!=Wall)
{
display(x,y);
x++;
}
break;
case 75: //向左走
if(map[x][y-1]!=Wall)
{
display(x,y);
y--;
}
break;
case 77: //向右走
if(map[x][y+1]!=Wall)
{
display(x,y);
y++;
}
break;
case 112: //按下P
gonglue(2,1);break; //如果按下P执行攻略函数
}
}
}
}
void Wanjia::shang(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
exit(0);
}
if(map[x-1][y]!=Wall&&map[x-1][y]!=up&&map[x-1][y]!=down&&map[x-1][y]!=left&&map[x-1][y]!=right&&map[x-1][y]!=flag)
{ //当移动后的下一个位置没有被走过且不是墙
map[x][y]=up;
display(x,y);
x--;
gonglue(x,y); //递归，攻略下一个点
}
}
void Wanjia::xia(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
exit(0);
}
if(map[x+1][y]!=Wall&&map[x+1][y]!=up&&map[x+1][y]!=down&&map[x+1][y]!=left&&map[x+1][y]!=right&&map[x+1][y]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=down;
display(x,y);
x++;
gonglue(x,y); //递归，攻略下一个点
}
}
void Wanjia::zuo(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
exit(0);
}
if(map[x][y-1]!=Wall&&map[x][y-1]!=up&&map[x][y-1]!=down&&map[x][y-1]!=left&&map[x][y-1]!=right&&map[x][y-1]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=left;
display(x,y);
y--;
gonglue(x,y); //递归，攻略下一个点
}
}
void Wanjia::you(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
exit(0);
}
if(map[x][y+1]!=Wall&&map[x][y+1]!=up&&map[x][y+1]!=down&&map[x][y+1]!=left&&map[x][y+1]!=right&&map[x][y+1]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=right;
display(x,y);
y++;
gonglue(x,y); //递归，攻略下一个点
}
}
void Wanjia::gonglue (int x,int y)
{
gotoxy(2y-2,x-1);
cout<<"☆"; //画出玩家当前位置
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout<<"到达终点，按任意键结束";
getch();
exit(0);
}
shang(x,y); //上下左右
xia(x,y);
zuo(x,y);
you(x,y);
map[x][y]=flag; //当上下左右都无法走的时候，即为死路，因为递归函数开始向后，所以讲死路点值置为flag，变成无形之墙。
display(x,y);
}
int main()
{
cout<<" 移动迷宫 "<<endl;
cout<<"--------------------"<<endl;
cout<<"欢迎来到移动迷宫游戏"<<endl;
cout<<"--------------------"<<endl;
cout<<"游戏说明：给定一出口和入口"<<endl;
cout<<"玩家控制一个五角星（☆）从入口走到出口"<<endl;
cout<<"系统会记录你所走的步数"<<endl;
cout<<"按回车进入游戏";
cout<<"(按下P键可以获得攻略。)";
getch();
system("cls"); //清屏函数 ，清除开始界面
Wanjia w1;
w1chushi();
w1game(); //开始游戏
// w1gonglue(2,1); //功略显示
getch();
return 0;
}
————————————————
版权声明：本文为CSDN博主「失落之风」的原创文章，遵循 CC 40 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：>
以上就是关于编程走迷宫创作背景目的和意义全部的内容，包括:编程走迷宫创作背景目的和意义、C语言编程 迷宫问题(队列)、迷宫问题求错 c语言程序 程序代码如下 ： 但程序总无输出等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）