栈实现

邓俊辉数据结构 栈实现

学堂在线 栈教学视频
环境：DEV C++5.4.0。有课程资源但是无法运行，于是自己结合视频敲了一边，函数名称尽量与视频中统一，有细微的不同。
栈可以由向量和LIST实现。这里实现了栈的入栈、出栈、查询是否为空、查询顶部函数。
**经典应用 ：**括号匹配、进展转换
向量代码
列表实现

1.向量实现栈
这里采用的是聚合方式

#include "vector.hpp"
template <typename T>
class Stack{
private:
	Vector<T> stack;
public:
	unsigned int size();
	bool empty();
	void push(T const &e);
	T pop();
	T top();
	
};
template <typename T>
unsigned int Stack<T>::size(){
	return stack.getSize();
}

template <typename T>
bool Stack<T>::empty(){
	return stack.getSize()==0?true:false;
}

template <typename T>
void Stack<T>::push(T const &e){
	stack.insert(stack.getSize(),e);
}

template <typename T>
T Stack<T>::pop(){
	return stack.remove(stack.getSize()-1);	
}

template <typename T>
T Stack<T>::top(){
	return stack[stack.getSize()-1];
} 

2.向量实现栈采用 继承方式
教学视频中采用的方式，代码比较短

#include "vector.hpp"
template <typename T>
class Stack:public Vector<T>{

public:
	void push(T const &e){this->insert(this->getSize(),e);}
	T pop(){return this->remove(this->getSize()-1);	}
	T &top(){return (*this)[this->getSize()-1];//取顶 
	}
	bool empty(){ return this->getSize()==0?true:false;}
};

3.List实现栈
这里只给出继承方式

#include "List.hpp" 
template <typename T>
class Stack:public List<T>{
	
public:
	Stack(){this->init();}
	void push(T const &e){this->insertBefore(this->first(),e);}
	T pop(){return this->remove(this->first());}
	T &top(){return this->first()->data;
	}
};

测试栈
括号匹配、进制转换

#include <iostream>
#include "Stack.hpp"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

void convert(Stack<char> &S,__int64 n,int base);
bool patch(char *s,unsigned int n);//括号匹配 
int main(int argc, char *argv[]) {
	Stack<int> s;
	Stack<char> s1;
	char *bracket="((()()))()";
	long int c=1814231234;
	std::cout<<s.empty()<<std::endl;
	s.push(c);
	s.push(3);
	std::cout<<s.pop()<<std::endl;
	s.push(7);
	s.push(3);
	std::cout<<s.top()<<std::endl;
	std::cout<<s.empty()<<std::endl;
	s.push(11);
	std::cout<<s.getSize()<<std::endl;
	/*
	while(!s.empty()){
		
		std::cout<<s.pop()<<std::endl;
	}
	std::cout<<"sizeof stack:"<<s.getSize()<<std::endl;//0
	
	std::cout<<"begien controcvers:"<<c<<std::endl;
	convert(s1,c,8);
	while(!s1.empty()){
		std::cout<<s1.pop();
	}
	
	std::cout<<"\nsizeof stack:"<<s.getSize()<<std::endl;//0
	
	std::cout<<"begien controcvers:"<<c<<std::endl;
	convert(s1,c,16);
	while(!s1.empty()){
		std::cout<<s1.pop();
	}*/
	std::cout<<patch(bracket,9);
	return 0;
}
//进制转换。base是底数（进制），n是转换的数值，S结果返回的栈。 
void convert(Stack<char> &S,__int64 n,int base){
	char *digit="0123456789ABCDEF";
	do{
		S.push(digit[n%base]);
		n/=base;
	}while(n>0);
} 

//括号匹配 
bool patch(char *s,unsigned int n){
	unsigned int count=0;
	unsigned int i=0;
	while(i<n){
		if(s[i]=='(') count++;
		else if(s[i]==')'){
			if(count==0)
				return false;//不匹配
			else
				count--; 
		}
		i++;
	}
	if(count!=0)	return false;
	else 			return true;
}



//中缀表达式计算
template <class T>//参数s: 中缀表达式 以\0结尾;目标参数T返回值类型,运算数类型 
T evaluat(char *s)
{
	Stack<T> num;//操作数 
	Stack<char> op;//操作符 
	op.push('\0');//先插入一个结束符，后文判断结束 
	int i=0;
	while(op.empty())//扫描转换 
	{
		if(isdigit(*s))
		{
			//T n=rednum(s[i]);//多位数，转化为可计算的类型 
		  //num.push(n);
		  readnum<T>(s,num);	
		}else //若当前字符为运算符，则视其与栈顶操作符的高低 
		  switch(orderBetween(optr.top(),*s)); 
	} 
	return opnd.pop();//弹出并返回 
} 
//判断字符s是否是数字 
bool  isdigit(char s)
{
 return (s<='9' && s>='0'); 
}

template <class T>
void readnum(char **s,Stack<T> &num)
{
	T n;//数字栈
	 n=(**s)-'0';
	 *s++;
	while(isdigit(**s))
	{
	 n=*10;
	 n=(**s)-'0';
	}
	num.push(num);
}



//将一个算式转化为逆波兰表达式 ：想法，按照手工的办法，将运算符放大限定它符号的后面，然后去掉所有运算符。 
//{([0!]+1)^([(2*[3!])+4]-5)}
template<class T>
T RPN(char *s){
	
}