c++ 链栈求解迷宫

#pragma once
#include <iostream>
using namespace std;

#define M 10
#define N 10

struct road
{
int x;
int y;
struct road *next;
};

const int map[M]
= {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 0, 0, 0, 0, 0, 0, 1, 1,
1, 0, 1, 1, 1, 1, 1, 0, 0, 1,
1, 0, 1, 0, 0, 1, 0, 0, 0, 1,
1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
1, 1, 1, 1, 1, 1, 0, 0, 0, 1,
1, 0, 1, 0, 0, 0, 1, 0, 1, 1,
1, 0, 0, 0, 0, 1, 0, 0, 0, 1,
1, 0, 0, 1, 0, 0, 0, 1, 0, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};

class maze
{
public:
maze();
bool check_up(int x, int y);
bool check_down(int x, int y);
bool check_right(int x, int y);
bool check_left(int x, int y);

void move_up(int x, int y);
void move_down(int x, int y);
void move_right(int x, int y);
void move_left(int x, int y);

void result(int x_s, int y_s, int x_r, int y_r);
void push();

void print();

void show();

~maze();
private:
char box[M]
;
struct road *head;
};

#include "Stack.h"

maze::maze()
{
for (int i = 0; i < M; i++)
{
for (int j = 0; j < N; j++)
{
box[i][j] = map[i][j];
}
}

head = new road;
head->next = NULL;
}

maze::~maze()
{
struct road *p = head;
while (head->next != NULL)
{
p = head;
head = head->next;
cout << "( " << p->x << ", " << p->y << ")" << endl;
delete p;
}
}

bool maze::check_up(int x, int y)
{
if (box[x - 1][y] == 0)
return true;
else
return false;
}
bool maze::check_down(int x, int y)
{
if (box[x + 1][y] == 0)
return true;
else
return false;
}
bool maze::check_right(int x, int y)
{
if (box[x][y+1] == 0)
return true;
else
return false;
}
bool maze::check_left(int x, int y)
{
if (box[x][y - 1] == 0)
return true;
else
return false;
}

void maze::move_up(int x, int y)
{
struct road *p;
p = new road;
p->x = x - 1;
p->y = y;
box[p->x][p->y] = 2;
p->next = head->next;
head->next = p;
}
void maze::move_down(int x, int y)
{
struct road *p;
p = new road;
p->x = x + 1;
p->y = y;
box[p->x][p->y] = 2;
p->next = head->next;
head->next = p;
}
void maze::move_right(int x, int y)
{
struct road *p;
p = new road;
p->x = x;
p->y = y + 1;
box[p->x][p->y] = 2;
p->next = head->next;
head->next = p;
}
void maze::move_left(int x, int y)
{
struct road *p;
p = new road;
p->x = x;
p->y = y - 1;
box[p->x][p->y] = 2;
p->next = head->next;
head->next = p;
}

void maze::push()
{
struct road *p = head->next;
head->next = p->next;
delete p;
}

void maze::result(int x_s, int y_s, int x_r, int y_r)
{
struct road *p;
p = new road;
p->x = x_s;
p->y = y_s;
box[p->x][p->y] = 2;
p->next = head->next;
head->next = p;
p = head->next;
while (p->x != x_r || p->y != y_r)
{

if (check_up(p->x, p->y))
move_up(p->x, p->y);

else if (check_down(p->x, p->y))
move_down(p->x, p->y);

else if (check_right(p->x, p->y))
move_right(p->x, p->y);

else if (check_left(p->x, p->y))
move_left(p->x, p->y);

else
push();

p = head->next;
}
}

void maze::show()
{
struct road *p = head->next;
while (head->next != NULL)
{
head->next = p->next;
cout << "( " << p->x << ", " << p->y << ")" << endl;
box[p->x][p->y] = 3;
delete p;
p = head->next;
}
}

void maze::print()
{
for (int i = 0; i < M; i++)
{
for (int j = 0; j < N; j++)
{
if (box[i][j] == 1)
cout << " * ";
if (box[i][j] == 2)
cout << " . ";
if (box[i][j] == 0)
cout << "   ";
if (box[i][j] == 3)
cout << " 。";
}
cout << endl;
}
}

#include "Stack.h"

int main()
{
maze R;
R.result(1,1,M-2,N-2);
R.show();
R.print();
system("pause");
return 0;
}