-------------------siwuxie095
栈
这里介绍 栈，那么什么是栈呢？
从字面意思上来解释：栈者，牲口棚也
也就是说，在古代，栈就是牲口棚的意思
那么在计算机中，栈是什么呢？栈是一种机制
我们把这种机制也称为 栈机制，简言之，就是 后进先出，
即 Last In First Out，简称 LIFO
如：当进入电梯时，先进电梯的人，在乘坐电梯之后，
他一定是后出来，而后进电梯的人，在乘坐电梯之后，
他一定是先出来
从数据结构的角度上来讲，如果有一张表，用它来存各种元素，
则称之为 栈
当这张表是空表时，称之为 空栈，在向这张表中放数据之前，
栈就拥有一个 栈底 和一个 栈顶
栈底 和 栈顶 在栈中没有数据时，它们都指向最后一个元素，
即 最下面的那个元素，当开始放数据之后，栈顶 就会不断的
升高，当取出数据时，栈顶 也会逐渐的降低
栈顶 和 栈底 也都称之为 栈要素
虽然栈的原理非常简单，但是栈的用途却非常大，如下：
（1）进制转换
（2）括号匹配检验
程序 1：
MyStack.h：
|
#ifndef MYSTACK_H #define MYSTACK_H
class MyStack { public: MyStack(int size); //分配内存初始化栈空间，设定栈容量，栈顶 ~MyStack(); //回收栈空间内存 bool stackEmpty(); //判断栈是否为空 bool stackFull(); //判断栈是否为满 void clearStack(); //清空栈 int stackLength(); //已有元素的个数 bool push(char elem); //元素入栈，栈顶上升 bool pop(char &elem); //元素出栈，栈顶下降 void stackTraverse(bool isFromBottom); //遍历栈中所有元素 private: char *m_pBuff; //栈空间指针 int m_iSize; //栈容量 int m_iTop; //栈顶，栈中元素个数 //栈底不用写，因为它永远不变，可以认为是 0 };
//掌握栈的实现原理和运行机制 #endif |
MyStack.cpp：
|
#include "MyStack.h" #include "stdlib.h" #include <iostream> using namespace std;
MyStack::MyStack(int size) { //初始化栈容量 m_iSize = size; //采用数组的形式，为栈分配内存空间 m_pBuff = new char[m_iSize]; //栈顶为 0，即为空栈 m_iTop = 0; }
MyStack::~MyStack() { delete[]m_pBuff; m_pBuff = NULL; }
bool MyStack::stackEmpty() { //如果栈顶为 0，则为空栈 // //可以将 m_iTop==0 改写为 0==m_iTop 来提高代码质量 //因为当只写了一个等号时，后者会报错，而前者不会 if (0 == m_iTop) { return true; } return false; //或写成如下形式： //return m_iTop == 0 ? true : false; }
bool MyStack::stackFull() { //如果栈顶等于（或大于等于）栈的容量，即满栈 if (m_iTop == m_iSize)// >= { return true; } return false;
//或写成如下形式： //return m_iTop == m_iSize ? true : false; }
void MyStack::clearStack() { //作为一个栈来说，里面的数据可以全为0，也可以不为0 //但这并不重要，因为判断当前位置有没有被使用，不取 //决于里面的数据，而取决于栈顶 m_iTop，当栈顶为0时， //栈就被"清空"了，原有数据全部无效，将来再放数据时， //覆盖原来的数据即可 m_iTop = 0; }
int MyStack::stackLength() { return m_iTop; }
//入栈：将元素放到栈顶 bool MyStack::push(char elem) { //如果栈满，就无法入栈 // //栈满的处理方法有两种： //一种是返回值为bool，直接返回false //一种是返回值为void，通过throw抛出异常 if (stackFull()) { return false; }
//将元素放到栈顶 m_pBuff[m_iTop] = elem;
//元素存放完毕，栈顶就相应的上浮， //指向下一个要入栈的位置，即空位置 m_iTop++;
return true;
}
//弹栈：也称出栈，将栈顶元素出栈 bool MyStack::pop(char &elem) { //如果栈为空，就无法出栈 // //栈为空的处理方法也有两种： //一种是返回值为void，直接返回false //一种是返回值为char，同时没有参数，并抛出异常 if (stackEmpty()) { return false; }
//因为栈顶总是指向下一个空的位置 //所以要先m_iTop--，使得栈顶指向 //一个拥有元素的位置,才能出栈 m_iTop--;
//将当前栈顶元素赋值给elem elem = m_pBuff[m_iTop];
return true; }
////弹栈时栈为空的另一种处理方法 //char MyStack::pop() //{ // if (stackEmpty()) // { // throw 1; // } // // m_iTop--; // // return m_pBuff[m_iTop]; //}
void MyStack::stackTraverse(bool isFromBottom) { if (isFromBottom) { //从栈底向栈顶做遍历 for (int i = 0; i < m_iTop; i++) { cout << m_pBuff[i] << " , "; } } else { //从栈顶向栈底做遍历 for (int i = m_iTop - 1; i >= 0; i--) { cout << m_pBuff[i] << " , "; } }
cout << endl; } |
main.cpp：
|
#include "MyStack.h" #include "stdlib.h" #include <iostream> using namespace std;
int main(void) { MyStack *p = new MyStack(5);
p->push('h');//栈底 p->push('e'); p->push('l'); p->push('l'); p->push('o');//栈顶 p->stackTraverse(true);
char elem = 0; p->pop(elem); cout << elem << endl;
p->stackTraverse(true);
//p->clearStack(); if (p->stackEmpty()) { cout << "栈为空" << endl; } else if (p->stackFull()) { cout << "栈为满" << endl; } else { cout << "栈中有 " << p->stackLength() << " 个元素" << endl; }
delete p; p = NULL;
system("pause"); return 0; } |
运行一览：
程序 2：
Coordinate.h：
|
#ifndef COORDINATE_H #define COORDINATE_H
class Coordinate { public: Coordinate(int x = 0, int y = 0); void printCoordinate(); private: int m_iX; int m_iY; };
//当Coordinate的对象或引用作参数时，会调用拷贝构造函数， //因为这里Coordinate的数据成员比较简单，没有涉及到指针， //就使用默认拷贝构造函数即可 #endif |
Coordinate.cpp：
|
#include "Coordinate.h" #include <iostream> using namespace std;
Coordinate::Coordinate(int x, int y) { m_iX = x; m_iY = y; }
void Coordinate::printCoordinate() { cout << "(" << m_iX << "," << m_iY << ")" << endl; } |
MyStack.h：
|
#ifndef MYSTACK_H #define MYSTACK_H
#include "Coordinate.h"
class MyStack { public: MyStack(int size); //分配内存初始化栈空间，设定栈容量，栈顶 ~MyStack(); //回收栈空间内存 bool stackEmpty(); //判断栈是否为空 bool stackFull(); //判断栈是否为满 void clearStack(); //清空栈 int stackLength(); //已有元素的个数 bool push(Coordinate elem); //元素入栈，栈顶上升 bool pop(Coordinate &elem); //元素出栈，栈顶下降 void stackTraverse(bool isFromBottom); //遍历栈中所有元素 private: Coordinate *m_pBuff;//Coordinate类型的栈空间指针 int m_iSize; //栈容量 int m_iTop; //栈顶，栈中元素个数 //栈底不用写，因为它永远不变，可以认为是 0 };
//掌握栈的实现原理和运行机制 #endif |
MyStack.cpp：
|
#include "MyStack.h" #include "stdlib.h" #include <iostream> using namespace std;
MyStack::MyStack(int size) { //初始化栈容量 m_iSize = size; //采用数组的形式，为栈分配内存空间 m_pBuff = new Coordinate[m_iSize]; //栈顶为 0，即为空栈 m_iTop = 0; }
MyStack::~MyStack() { delete[]m_pBuff; m_pBuff = NULL; }
bool MyStack::stackEmpty() { //如果栈顶为 0，则为空栈 // //可以将 m_iTop==0 改写为 0==m_iTop 来提高代码质量 //因为当只写了一个等号时，后者会报错，而前者不会 if (0 == m_iTop) { return true; } return false;
//或写成如下形式： //return m_iTop == 0 ? true : false; }
bool MyStack::stackFull() { //如果栈顶等于（或大于等于）栈的容量，即满栈 if (m_iTop == m_iSize)// >= { return true; } return false;
//或写成如下形式： //return m_iTop == m_iSize ? true : false; }
void MyStack::clearStack() { //作为一个栈来说，里面的数据可以全为0，也可以不为0 //但这并不重要，因为判断当前位置有没有被使用，不取 //决于里面的数据，而取决于栈顶 m_iTop，当栈顶为0时， //栈就被"清空"了，原有数据全部无效，将来再放数据时， //覆盖原来的数据即可 m_iTop = 0; }
int MyStack::stackLength() { return m_iTop; }
//入栈：将元素放到栈顶 bool MyStack::push(Coordinate elem) { //如果栈满，就无法入栈 // //栈满的处理方法有两种： //一种是返回值为bool，直接返回false //一种是返回值为void，通过throw抛出异常 if (stackFull()) { return false; }
//将元素放到栈顶 m_pBuff[m_iTop] = elem;
//元素存放完毕，栈顶就相应的上浮， //指向下一个要入栈的位置，即空位置 m_iTop++;
return true;
}
//弹栈：也称出栈，将栈顶元素出栈 bool MyStack::pop(Coordinate &elem) { //如果栈为空，就无法出栈 // //栈为空的处理方法也有两种： //一种是返回值为void，直接返回false //一种是返回值为char，同时没有参数，并抛出异常 if (stackEmpty()) { return false; }
//因为栈顶总是指向下一个空的位置 //所以要先m_iTop--，使得栈顶指向 //一个拥有元素的位置,才能出栈 m_iTop--;
//将当前栈顶元素赋值给elem elem = m_pBuff[m_iTop];
return true; }
////弹栈时栈为空的另一种处理方法 //char MyStack::pop() //{ // if (stackEmpty()) // { // throw 1; // } // // m_iTop--; // // return m_pBuff[m_iTop]; //}
void MyStack::stackTraverse(bool isFromBottom) { if (isFromBottom) { //从栈底向栈顶做遍历 for (int i = 0; i < m_iTop; i++) { m_pBuff[i].printCoordinate(); } } else { //从栈顶向栈底做遍历 for (int i = m_iTop - 1; i >= 0; i--) { m_pBuff[i].printCoordinate(); } }
cout << endl; } |
main.cpp：
|
#include "MyStack.h" #include "stdlib.h" #include <iostream> using namespace std;
int main(void) { MyStack *p = new MyStack(5);
p->push(Coordinate(1,2));//栈底 p->push(Coordinate(3,4)); p->push(Coordinate(5,6)); p->push(Coordinate(7,8));//栈顶 p->stackTraverse(true);
Coordinate elem(0, 0); p->pop(elem); elem.printCoordinate(); cout << endl;
p->stackTraverse(false);
//p->clearStack(); if (p->stackEmpty()) { cout << "栈为空" << endl; } else if (p->stackFull()) { cout << "栈为满" << endl; } else { cout << "栈中有 " << p->stackLength() << " 个元素" << endl; }
delete p; p = NULL;
system("pause"); return 0; } |
运行一览：
程序 3：应用类模板
Coordinate.h：
|
#ifndef COORDINATE_H #define COORDINATE_H
#include <ostream> using namespace std;
class Coordinate { friend ostream &operator<<(ostream &out, Coordinate &coor);
public: Coordinate(int x = 0, int y = 0); void printCoordinate(); private: int m_iX; int m_iY;
};
//当Coordinate的对象或引用作参数时，会调用拷贝构造函数， //因为这里Coordinate的数据成员比较简单，没有涉及到指针， //就使用默认拷贝构造函数即可 #endif |
Coordinate.cpp：
|
#include "Coordinate.h" #include <iostream> using namespace std;
Coordinate::Coordinate(int x, int y) { m_iX = x; m_iY = y; }
void Coordinate::printCoordinate() { cout << "(" << m_iX << "," << m_iY << ")" << endl; }
ostream &operator<<(ostream &out, Coordinate &coor) {
cout << "(" << coor.m_iX << "," << coor.m_iY << ")" << endl; return out; } |
MyStack.h：
|
#ifndef MYSTACK_H #define MYSTACK_H
#include "stdlib.h"
template<typename T> class MyStack { public: MyStack(int size); //分配内存初始化栈空间，设定栈容量，栈顶 ~MyStack(); //回收栈空间内存 bool stackEmpty(); //判断栈是否为空 bool stackFull(); //判断栈是否为满 void clearStack(); //清空栈 int stackLength(); //已有元素的个数 bool push(T elem); //元素入栈，栈顶上升 bool pop(T &elem); //元素出栈，栈顶下降 void stackTraverse(bool isFromBottom); //遍历栈中所有元素 private: T *m_pBuff; //栈空间指针 int m_iSize; //栈容量 int m_iTop; //栈顶，栈中元素个数 //栈底不用写，因为它永远不变，可以认为是 0 };
//掌握栈的实现原理和运行机制
template<typename T> MyStack<T>::MyStack(int size) { //初始化栈容量 m_iSize = size; //采用数组的形式，为栈分配内存空间 m_pBuff = new T[m_iSize]; //栈顶为 0，即为空栈 m_iTop = 0; }
template<typename T> MyStack<T>::~MyStack() { delete[]m_pBuff; m_pBuff = NULL; }
template<typename T> bool MyStack<T>::stackEmpty() { //如果栈顶为 0，则为空栈 // //可以将 m_iTop==0 改写为 0==m_iTop 来提高代码质量 //因为当只写了一个等号时，后者会报错，而前者不会 if (0 == m_iTop) { return true; } return false;
//或写成如下形式： //return m_iTop == 0 ? true : false; }
template<typename T> bool MyStack<T>::stackFull() { //如果栈顶等于（或大于等于）栈的容量，即满栈 if (m_iTop == m_iSize)// >= { return true; } return false;
//或写成如下形式： //return m_iTop == m_iSize ? true : false; }
template<typename T> void MyStack<T>::clearStack() { //作为一个栈来说，里面的数据可以全为0，也可以不为0 //但这并不重要，因为判断当前位置有没有被使用，不取 //决于里面的数据，而取决于栈顶 m_iTop，当栈顶为0时， //栈就被"清空"了，原有数据全部无效，将来再放数据时， //覆盖原来的数据即可 m_iTop = 0; }
template<typename T> int MyStack<T>::stackLength() { return m_iTop; }
//入栈：将元素放到栈顶 template<typename T> bool MyStack<T>::push(T elem) { //如果栈满，就无法入栈 // //栈满的处理方法有两种： //一种是返回值为bool，直接返回false //一种是返回值为void，通过throw抛出异常 if (stackFull()) { return false; }
//将元素放到栈顶 m_pBuff[m_iTop] = elem;
//元素存放完毕，栈顶就相应的上浮， //指向下一个要入栈的位置，即空位置 m_iTop++;
return true;
}
//弹栈：也称出栈，将栈顶元素出栈 template<typename T> bool MyStack<T>::pop(T &elem) { //如果栈为空，就无法出栈 // //栈为空的处理方法也有两种： //一种是返回值为void，直接返回false //一种是返回值为T，同时没有参数，并抛出异常 if (stackEmpty()) { return false; }
//因为栈顶总是指向下一个空的位置 //所以要先m_iTop--，使得栈顶指向 //一个拥有元素的位置,才能出栈 m_iTop--;
//将当前栈顶元素赋值给elem elem = m_pBuff[m_iTop];
return true; }
////弹栈时栈为空的另一种处理方法 //template<typename T> //T MyStack<T>::pop() //{ // if (stackEmpty()) // { // throw 1; // } // // m_iTop--; // // return m_pBuff[m_iTop]; //}
template<typename T> void MyStack<T>::stackTraverse(bool isFromBottom) { if (isFromBottom) { //从栈底向栈顶做遍历 for (int i = 0; i < m_iTop; i++) { cout << m_pBuff[i] << endl; } } else { //从栈顶向栈底做遍历 for (int i = m_iTop - 1; i >= 0; i--) { cout << m_pBuff[i] << endl; } }
cout << endl; }
#endif |
main.cpp：
|
#include "MyStack.h" #include "Coordinate.h" #include "stdlib.h" #include <iostream> using namespace std;
int main(void) { MyStack<Coordinate> *p = new MyStack<Coordinate>(5);
p->push(Coordinate(1, 2));//栈底 p->push(Coordinate(3, 4)); p->push(Coordinate(5, 6)); p->push(Coordinate(7, 8));//栈顶 p->stackTraverse(true);
Coordinate elem(0, 0); p->pop(elem); elem.printCoordinate(); cout << endl;
p->stackTraverse(false);
//p->clearStack(); if (p->stackEmpty()) { cout << "栈为空" << endl; } else if (p->stackFull()) { cout << "栈为满" << endl; } else { cout << "栈中有 " << p->stackLength() << " 个元素" << endl; }
delete p; p = NULL;
system("pause"); return 0; } |
运行一览：
程序 4：进制转换
MyStack.h：
|
#ifndef MYSTACK_H #define MYSTACK_H
#include "stdlib.h"
template<typename T> class MyStack { public: MyStack(int size); //分配内存初始化栈空间，设定栈容量，栈顶 ~MyStack(); //回收栈空间内存 bool stackEmpty(); //判断栈是否为空 bool stackFull(); //判断栈是否为满 void clearStack(); //清空栈 int stackLength(); //已有元素的个数 bool push(T elem); //元素入栈，栈顶上升 bool pop(T &elem); //元素出栈，栈顶下降 void stackTraverse(bool isFromBottom); //遍历栈中所有元素 private: T *m_pBuff; //栈空间指针 int m_iSize; //栈容量 int m_iTop; //栈顶，栈中元素个数 //栈底不用写，因为它永远不变，可以认为是 0 };
//掌握栈的实现原理和运行机制
template<typename T> MyStack<T>::MyStack(int size) { //初始化栈容量 m_iSize = size; //采用数组的形式，为栈分配内存空间 m_pBuff = new T[m_iSize]; //栈顶为 0，即为空栈 m_iTop = 0; }
template<typename T> MyStack<T>::~MyStack() { delete[]m_pBuff; m_pBuff = NULL; }
template<typename T> bool MyStack<T>::stackEmpty() { //如果栈顶为 0，则为空栈 // //可以将 m_iTop==0 改写为 0==m_iTop 来提高代码质量 //因为当只写了一个等号时，后者会报错，而前者不会 if (0 == m_iTop) { return true; } return false;
//或写成如下形式： //return m_iTop == 0 ? true : false; }
template<typename T> bool MyStack<T>::stackFull() { //如果栈顶等于（或大于等于）栈的容量，即满栈 if (m_iTop == m_iSize)// >= { return true; } return false;
//或写成如下形式： //return m_iTop == m_iSize ? true : false; }
template<typename T> void MyStack<T>::clearStack() { //作为一个栈来说，里面的数据可以全为0，也可以不为0 //但这并不重要，因为判断当前位置有没有被使用，不取 //决于里面的数据，而取决于栈顶 m_iTop，当栈顶为0时， //栈就被"清空"了，原有数据全部无效，将来再放数据时， //覆盖原来的数据即可 m_iTop = 0; }
template<typename T> int MyStack<T>::stackLength() { return m_iTop; }
//入栈：将元素放到栈顶 template<typename T> bool MyStack<T>::push(T elem) { //如果栈满，就无法入栈 // //栈满的处理方法有两种： //一种是返回值为bool，直接返回false //一种是返回值为void，通过throw抛出异常 if (stackFull()) { return false; }
//将元素放到栈顶 m_pBuff[m_iTop] = elem;
//元素存放完毕，栈顶就相应的上浮， //指向下一个要入栈的位置，即空位置 m_iTop++;
return true;
}
//弹栈：也称出栈，将栈顶元素出栈 template<typename T> bool MyStack<T>::pop(T &elem) { //如果栈为空，就无法出栈 // //栈为空的处理方法也有两种： //一种是返回值为void，直接返回false //一种是返回值为T，同时没有参数，并抛出异常 if (stackEmpty()) { return false; }
//因为栈顶总是指向下一个空的位置 //所以要先m_iTop--，使得栈顶指向 //一个拥有元素的位置,才能出栈 m_iTop--;
//将当前栈顶元素赋值给elem elem = m_pBuff[m_iTop];
return true; }
////弹栈时栈为空的另一种处理方法 //template<typename T> //T MyStack<T>::pop() //{ // if (stackEmpty()) // { // throw 1; // } // // m_iTop--; // // return m_pBuff[m_iTop]; //}
template<typename T> void MyStack<T>::stackTraverse(bool isFromBottom) { if (isFromBottom) { //从栈底向栈顶做遍历 for (int i = 0; i < m_iTop; i++) { cout << m_pBuff[i]; } } else { //从栈顶向栈底做遍历 for (int i = m_iTop - 1; i >= 0; i--) { cout << m_pBuff[i]; } }
cout << endl; }
#endif |
main.cpp：
|
#include "MyStack.h" #include "stdlib.h" #include <iostream> using namespace std;
#define BINARY 2 #define OCTONARY 8 #define HEXADECIMAL 16
//描述：输入任意十进制正整数数N，分别输出该正整数N的二进制、八进制、十六进制的数 //公式：N=(N div d) * d + N mod d （div 表示整除，mod 表示求余，d 表示几进制） int main(void) { MyStack<int> *p = new MyStack<int>(20);
//N可以换为其它值测试 int N = 1348; int mod = 0;
while (N != 0) { //OCTONARY 换为 BINARY、HEXADECIMAL 进行测试 mod = N % OCTONARY; p->push(mod); N = N / OCTONARY; }
//p->stackTraverse(false);
//对于十六进制中大于等于10的部分用ABC...表示 char num[] = "0123456789ABCDEF";
//栈中的数据不变，让出栈的数据进行转换 int elem = 0; while (!p->stackEmpty()) { p->pop(elem); cout << num[elem]; }
delete p; p = NULL;
system("pause"); return 0; } |
程序 5：括号匹配
MyStack.h：
|
#ifndef MYSTACK_H #define MYSTACK_H
#include "stdlib.h"
template<typename T> class MyStack { public: MyStack(int size); //分配内存初始化栈空间，设定栈容量，栈顶 ~MyStack(); //回收栈空间内存 bool stackEmpty(); //判断栈是否为空 bool stackFull(); //判断栈是否为满 void clearStack(); //清空栈 int stackLength(); //已有元素的个数 bool push(T elem); //元素入栈，栈顶上升 bool pop(T &elem); //元素出栈，栈顶下降 void stackTraverse(bool isFromBottom); //遍历栈中所有元素 private: T *m_pBuff; //栈空间指针 int m_iSize; //栈容量 int m_iTop; //栈顶，栈中元素个数 //栈底不用写，因为它永远不变，可以认为是 0 };
//掌握栈的实现原理和运行机制
template<typename T> MyStack<T>::MyStack(int size) { //初始化栈容量 m_iSize = size; //采用数组的形式，为栈分配内存空间 m_pBuff = new T[m_iSize]; //栈顶为 0，即为空栈 m_iTop = 0; }
template<typename T> MyStack<T>::~MyStack() { delete[]m_pBuff; m_pBuff = NULL; }
template<typename T> bool MyStack<T>::stackEmpty() { //如果栈顶为 0，则为空栈 // //可以将 m_iTop==0 改写为 0==m_iTop 来提高代码质量 //因为当只写了一个等号时，后者会报错，而前者不会 if (0 == m_iTop) { return true; } return false;
//或写成如下形式： //return m_iTop == 0 ? true : false; }
template<typename T> bool MyStack<T>::stackFull() { //如果栈顶等于（或大于等于）栈的容量，即满栈 if (m_iTop == m_iSize)// >= { return true; } return false;
//或写成如下形式： //return m_iTop == m_iSize ? true : false; }
template<typename T> void MyStack<T>::clearStack() { //作为一个栈来说，里面的数据可以全为0，也可以不为0 //但这并不重要，因为判断当前位置有没有被使用，不取 //决于里面的数据，而取决于栈顶 m_iTop，当栈顶为0时， //栈就被"清空"了，原有数据全部无效，将来再放数据时， //覆盖原来的数据即可 m_iTop = 0; }
template<typename T> int MyStack<T>::stackLength() { return m_iTop; }
//入栈：将元素放到栈顶 template<typename T> bool MyStack<T>::push(T elem) { //如果栈满，就无法入栈 // //栈满的处理方法有两种： //一种是返回值为bool，直接返回false //一种是返回值为void，通过throw抛出异常 if (stackFull()) { return false; }
//将元素放到栈顶 m_pBuff[m_iTop] = elem;
//元素存放完毕，栈顶就相应的上浮， //指向下一个要入栈的位置，即空位置 m_iTop++;
return true;
}
//弹栈：也称出栈，将栈顶元素出栈 template<typename T> bool MyStack<T>::pop(T &elem) { //如果栈为空，就无法出栈 // //栈为空的处理方法也有两种： //一种是返回值为void，直接返回false //一种是返回值为T，同时没有参数，并抛出异常 if (stackEmpty()) { return false; }
//因为栈顶总是指向下一个空的位置 //所以要先m_iTop--，使得栈顶指向 //一个拥有元素的位置,才能出栈 m_iTop--;
//将当前栈顶元素赋值给elem elem = m_pBuff[m_iTop];
return true; }
////弹栈时栈为空的另一种处理方法 //template<typename T> //T MyStack<T>::pop() //{ // if (stackEmpty()) // { // throw 1; // } // // m_iTop--; // // return m_pBuff[m_iTop]; //}
template<typename T> void MyStack<T>::stackTraverse(bool isFromBottom) { if (isFromBottom) { //从栈底向栈顶做遍历 for (int i = 0; i < m_iTop; i++) { cout << m_pBuff[i]; } } else { //从栈顶向栈底做遍历 for (int i = m_iTop - 1; i >= 0; i--) { cout << m_pBuff[i]; } }
cout << endl; }
#endif |
main.cpp：
|
#include "MyStack.h" #include "stdlib.h" #include <string> #include <iostream> using namespace std;
//栈应用--括号匹配 //描述：任意输入一组括号，可以判断括号是否匹配（包括各种括号） //字符串示例：[()]、[()()]、[()[()]]、[[()] int main(void) { //p存储左括号，并非所有左括号 MyStack<char> *p = new MyStack<char>(30); //q存储右括号，并非所有右括号，而是急需匹配的字符 MyStack<char> *q = new MyStack<char>(30);
char str[] = "[()]";
//给currentNeed赋一个不可见的ASCII码值 char currentNeed = 0;
//扫描字符数组，即遍历 for (int i = 0; i < strlen(str); i++) { //如果扫描到的字符是急需匹配的字符，就都出栈 //否则，左括号入p栈，右括号入q栈 if (str[i] != currentNeed) { p->push(str[i]); switch (str[i]) { case '[': if (currentNeed!=0) { q->push(currentNeed); } currentNeed = ']'; break; case '(': if (currentNeed != 0) { q->push(currentNeed); } currentNeed = ')'; break; default: cout << "字符串括号不匹配" << endl; system("pause"); return 0; } } else { char elem; p->pop(elem); //q中的右括号会先变为空，所以必须判断是否为空 if (!q->pop(currentNeed)) { currentNeed = 0; } } }
if (p->stackEmpty()) { cout << "字符串括号匹配" << endl; } else { cout << "字符串括号不匹配" << endl; }
delete p; p = NULL; delete q; q = NULL; system("pause"); return 0; } |
【made by siwuxie095】