c++:栈的基本操作+实例：迷宫求解

栈的基本操作+实例：迷宫求解

#include<iostream>
using namespace std;

struct Node {
    int datai;
    int dataj;
    Node* next;
};
//栈
struct Stack {
    Node* pTop; //顶部指针
    Node* pBottom; //底部指针
};
void Init(Stack* pS);//初始化
//void CreateStack(Stack* pS);//建栈
void Push(Stack* pS, int vali, int valj);//压栈
bool Pop(Stack* pS);//出栈：把栈顶的结点删掉
bool getTop(Stack* pS, int& vali, int& valj);//获得栈顶元素：但不删除栈顶结点
bool isEmpty(Stack* pS);//判断栈顶是否为空
int getSize(Stack* pS);//获取栈的长度
void Travers(Stack* pS);//遍历栈
int main() {
    Stack s;
    int i = 0, j = 0;
    //定义迷宫矩阵
    int a[10][10] = {  0,0,0,0,0,0,0,0,0,0,
	               0,1,1,0,1,1,1,0,1,0,
                       0,1,1,0,1,1,1,0,1,0,
                       0,1,1,1,1,0,0,1,1,0,
                       0,1,0,0,0,1,1,1,0,0,//第五行
                       0,1,1,1,0,1,1,1,0,0,
                       0,1,0,1,1,1,0,1,1,0,
                       0,0,0,0,0,1,0,0,1,0,
                       0,1,1,1,1,1,1,1,1,0,
		       0,0,0,0,0,0,0,0,0,0, };
    //输出矩阵
    /*for (i = 0; i < 10; i++) {
	for (j = 0; j < 10; j++) {
	    cout << a0[i][j] << " ";//a0[i*columns+j]等价于a0[i][j]
	}
	cout << endl;
    }
    return 0;*/
    Init(&s);
    Push(&s, 1, 1);
    i = 1; 
    j = 1;//起点
    //四个方向，从右开始顺时针
    while (i != 8 || j != 8) {
	//四个方向，从右开始顺时针
	if (a[i+1][j] == 0) {
	    if (a[i][j + 1] == 0) {
		if (a[i - 1][j] == 0) {
		    if (a[i][j - 1] == 0) {
			a[i][j] = 0; Pop(&s); getTop(&s, i, j);
		    }
		    else { j--; Push(&s, i, j); a[i][j] = 0;}
		}
		else { i--; Push(&s, i, j); a[i][j] = 0;}
	    }
	    else { j++; Push(&s, i, j); a[i][j] = 0;}
	}
	else { i++; Push(&s, i, j); a[i][j] = 0;}
    }
   // Travers(&s);
    //新建一个栈接受已压好的栈用以逆序输出栈
    Stack r;
    Init(&r);
    for  (int n = 0;  n < getSize(&s);  i++)
    {
	getTop(&s,i,j);
	Pop(&s);
	Push(&r, i, j);
    }
    Travers(&r);

}
//初始化
 void Init(Stack * pS){
    pS->pTop = new Node();
    if (pS->pTop == NULL) {
	cerr << "动态内存分配失败！" << endl;
	exit(1);
    }
    pS->pBottom = pS->pTop;//顶部指针和底部指针指向同一个位置
    pS->pTop->next = NULL;
}
//建栈
/*void CreateStack(Stack* pS) {
    int val;
    cout << "请输入各个元素值：" << endl;
    while (cin >> val && val != -1)
    {
	Push(pS, val);
    }
}*/
//压栈
void Push(Stack* pS, int vali,int valj) {
    Node* newNode = new Node();//新建结点
    if (newNode == NULL) {
	cerr << "动态内存分配失败" << endl;
	exit(1);
    }
    newNode->datai = vali;
    newNode->dataj = valj;
    newNode->next = pS->pTop;
    pS->pTop = newNode;
}
//遍历栈
void Travers(Stack* pS) {
    Node* p = pS->pTop;
    while (p!=pS->pBottom)
    {
	cout << '('<<p->datai + 1<<','<<p->dataj + 1 <<')'<< "—>";
	p = p->next;
    }
    cout << endl;
}
//判断栈是否为空：通过比较栈顶和栈尾是否相等，如相等，说明为空
bool isEmpty(Stack* pS) {
    if (pS->pTop == pS->pBottom)
	return true;
    return false;
}
//出栈：把栈顶的结点删掉
bool Pop(Stack* pS) {
    if (isEmpty(pS))
	return false;
    Node* r = pS->pTop;//暂存顶指针
    pS->pTop = r->next;//栈顶指针下移一个结点
    delete r;//释放空间
    r = NULL;
    return true;
}
//获取栈顶元素：但不删除栈顶结点
bool getTop(Stack* pS, int& vali,int& valj) {
    if (isEmpty(pS))
	return false;
    vali = pS->pTop->datai;
    valj = pS->pTop->dataj;
    return true;
}
//获取栈的长度
int getSize(Stack* pS) {
    int len = 0;
    Node* p = pS->pTop;
    while (p != pS->pBottom) {
	len++;
	p = p->next;
    }
    return len;
}