数据结构的学习之顺序栈走迷宫问题

数据结构的学习之顺序栈走迷宫问题

给定一数组表示的迷宫，1为可通，0为不可通。（此处用bool数组表示省点空间）。

具体实现的.h 文件如下

```cpp
#pragma once
#include <crtdbg.h>
#include <iostream>
#ifndef _STACK_H
#define _STACK_H

//typedef int Selemtype ;

#define  STACK_INIT_SIZE     80  
#define  STACKINCREMENT    10 
#define  OVERFLOW   -1 


using namespace std;

typedef struct {
	int ord;
	int seat[2];
	int di;
}Selemtype;


typedef struct stack
{
	Selemtype* base;
	Selemtype* top;
	int size;
}SqStack;



int Createstack(stack& S) ;

int GetTop(SqStack S, Selemtype& e);

int push(SqStack& S, Selemtype e);

void assign_e(Selemtype& e, int curstep, int curpos[], int  di);

int pop(stack& S, Selemtype& e); //删除一个栈顶元素并返回这个值

bool StackEmpty(stack S);

//以上为stack的基本函数


void assign_a(int a[], int a1, int b); 

void assign_e(Selemtype& e, int curstep, int curpos[], int  di);

bool equal(int a[], int b[]);

bool pass(stack S, int curpos[], bool maze[10][10]);

void move(int a[], int b);

int MazePath(bool maze[][10], int start[], int end[]);


#endif

以下为.cpp文件

#include "stack.h"

int Createstack(stack& S){
S.base = (Selemtype*)malloc(STACK_INIT_SIZE * sizeof(Selemtype));
if (!S.base) exit(OVERFLOW);
S.top = S.base;
S.size = STACK_INIT_SIZE;
return 1;
}


int GetTop(SqStack S, Selemtype& e){
	if (S.top = S.base)return 0;
	e = *(S.top - 1);
	return 1;
}

int push(SqStack& S, Selemtype e){
	if (S.top - S.base >= S.size) {
		S.base = (Selemtype*)realloc(S.base, (STACKINCREMENT + S.size) * sizeof(Selemtype));
		if (!S.base) exit(OVERFLOW);
		S.top = S.base + S.size;
		S.size += STACKINCREMENT;
	}
	*S.top++ = e;
}

int pop(stack& S, Selemtype& e) {
	if (S.top == S.base) return 0;
	S.top--;
	assign_e(e, S.top->ord, S.top->seat, S.top->di);
	return 1;
}

bool StackEmpty(stack S) {
	if (S.base == S.top)
	{
		return 1;
	}
	else return 0;
}

void assign_a(int a[], int a1, int b) {
	a[0] = a1;
	a[1] = b;
}

void assign_e(Selemtype& e, int curstep, int curpos[], int  di){
	e.di = di; e.ord = curstep;
	e.seat[0] = curpos[0];
	e.seat[1] = curpos[1];
}
bool equal(int a[], int b[]){
	int* a1 = a; int* b1 = b;
	if ((*a1 == *b1) && (*(++b1) == *(++a1))) return 1;
	else return 0;
}

bool pass(stack S, int curpos[], bool maze[10][10]) {
	Selemtype* p = S.base;
	while (p != S.top) {
		if (equal(p->seat, curpos))  return 0;
		p++;
	}
	if (maze[curpos[0]][curpos[1]] == 1) return 0;

	return 1;
}

void move(int a[], int b) {
	switch (b)
	{
	case 1: a[1]++; break;
	case 2: a[0]++; break;
	case 3: a[1]--; break;
	case 4:	a[0]--; break;
	}
}

void MarkPrint(int a, int b, bool maze[][10]) {
	maze[a][b] = 1;
}

void showthepath(stack S, int end[]) {
	Selemtype* p = S.base;
	while (p != S.top)
	{
		cout << "--->"<< p->seat[0] << "and" << p->seat[1] ;
		p++;
	}
}


bool MazePath(bool maze[][10], int start[], int end[]) {
	stack S;	Createstack(S);		int curpos[2] = { -1,-1 };	memcpy(curpos, start, sizeof(curpos));
	int curstep = 1;	 Selemtype e; //此处的e为下一个要去的地方，用来试水的
	do {
		if (pass(S, curpos, maze)) {//如果能过
			assign_e(e, curstep, curpos, 1);
			push(S, e);
			if (equal(curpos, end)) {
				showthepath(S,end);
				return 1;
			}
			move(curpos, 1);
			curstep++;
		}
		else
		{
			if (!StackEmpty(S))//如果过不了
			{
				pop(S, e);
				while (e.di == 4 && !StackEmpty(S)) {//往后退到还有能走的块为止
					MarkPrint(e.seat[0], e.seat[1], maze); pop(S, e);//这个块所有的可能都尝试了，就标1和封住没区别。
				}
				if (e.di < 4)
				{
					e.di++; 	push(S, e);
					memcpy(curpos, e.seat, sizeof(e.seat));
					move(curpos, e.di);
				}
			}
		}
	} while (!StackEmpty(S));//栈不空，还有可能走的地。S
	return 0;
}

其中用到了很香的memcpy函数可以直接把数组内容拷贝过去，不用费时费力的再去循环，就非常的爽。
用法是直接memcpy（to,from,sizeof(to)）。在iostream头文件中就有。