栈
来源：互联网 发布：二手域名 编辑：程序博客网 时间：2024/04/26 08:23
-------------------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 =newchar[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");
return0;
}
运行一览：
程序 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");
return0;
}
运行一览：
程序 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");
return0;
}
运行一览：
程序 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");
return0;
}
程序 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");
return0;
}
}
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");
return0;
}
【made by siwuxie095】
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 栈
- 深化Java基础之——数组与内存控制
- Java I/O 学习总结（一）
- Java I/O 学习总结（二）
- 深化Java基础之——对象与内存控制
- Java实现常见的排序算法
- 栈
- (SystemJS) Can't resolve all parameters for
- @Autowired默认规则
- 关于Office Professional Plus 2013 VOL 和Office Professional Plus 2013
- wget 无法建立ssl连接 ERROR: certificate common name “a.ssl.fastly.net”
- service的简介
- AlexNet论文翻译与解读
- 微信小程序登录页动画-云层漂浮
- jquery EasyUi combobox 控件样式修改（对当前combobox的修改）
