数据结构之栈

栈：先进后出

栈的实现代码及两个实际应用(模板类)：
1.进制转换
2.括号匹配

/*********************************MyStack.h*******************************************/
#pragma once
#include<stdlib.h>
//#include"MyStack.h"
#include"Coordinate.h"
using namespace std;

/*
栈类
要求：
MyStack(int size);      //分配内存初始化栈空间，设定栈容量，栈顶
~MyStack();             //回收占空间内存
bool stackEmpty();      //判定栈是否为空，为空返回True,非空返回False
bool stackFull();       //判定栈是否为满，为满返回True,非空返回False
void clearStack();      //清空栈
int stackLength();      //栈中已有元素的个数
void push(char elem);   //元素入栈，栈顶上升 
char pop(char &elem);   //元素出栈，栈顶下降
void stackTraverse();   //遍历栈中所有元素 

目的：掌握栈的实现原理

*/

template<typename T>
class MyStack 
{
public:
	MyStack(int size=0);      //分配内存初始化栈空间，设定栈容量，栈顶
	virtual ~MyStack();             //回收占空间内存
	bool stackEmpty();      //判定栈是否为空，为空返回True,非空返回False
	bool stackFull();       //判定栈是否为满，为满返回True,非空返回False
	void clearStack();      //清空栈
	int stackLength();      //栈中已有元素的个数
	void push(T elem);   //元素入栈，栈顶上升 
	bool pop(T &elem);   //元素出栈，栈顶下降
	void stackTraverse(bool isFromButtom);   //遍历栈中所有元素 

private:
	int m_iTop;   //栈顶，占中元素个数
	T *m_pBuffer;//栈空间指针
	int m_iCapacity;//栈容量
};



template<typename T>
MyStack<T>::MyStack(int size)     //分配内存初始化栈空间，设定栈容量，栈顶
{
	m_iTop = 0;
	m_iCapacity = size;
	m_pBuffer = new T[m_iCapacity];
}
template<typename T>
MyStack<T>::~MyStack()           //回收占空间内存
{
	delete[]m_pBuffer;
	m_pBuffer = NULL;

}

template<typename T>
bool MyStack<T>::stackEmpty()       //判定栈是否为空，为空返回True,非空返回False
{
	return m_iTop == 0 ? true : false;

}
template<typename T>
bool MyStack<T>::stackFull()        //判定栈是否为满，为满返回True,非空返回False
{
	return m_iTop >= m_iCapacity ? true : false;
}

template<typename T>
void MyStack<T>::clearStack()       //清空栈
{
	m_iTop = 0;
	//m_iBotom = 0;

}
template<typename T>
int MyStack<T>::stackLength()       //栈中已有元素的个数
{
	return m_iTop;

}
template<typename T>
void MyStack<T>::push(T elem)   //元素入栈，栈顶上升 
{
	if (!stackFull())
	{
		m_pBuffer[m_iTop] = elem;
		m_iTop++;
	}
	else cout << "栈满了" << endl;
}
template<typename T>
bool MyStack<T>::pop(T &elem)    //元素出栈，栈顶下降
{
	if (stackEmpty())
	{
		return false;
	}
	m_iTop--;                       //①   理解①②两行代码顺序交换后有啥不同  顺序②① 是先把栈顶的元素出栈后，elem就变成了一个空的地址 如果不需要取出出栈的元素，则不影响程序的运行，否则则会报读取位置访问冲突
	elem = m_pBuffer[m_iTop];       //②                                       顺序①②
	return true;
}
template<typename T>
void MyStack<T>::stackTraverse(bool isFromButtom)   //遍历栈中所有元素 
{
	if (isFromButtom)
	{
		for (int i = 0; i < m_iTop; i++)
		{
			cout << m_pBuffer[i] ;
		}
		cout << endl;
	}
	else 
	{
		for (int i = m_iTop - 1; i >= 0; i--)
		{
			cout << m_pBuffer[i];
		}
		cout << endl;
	}
}

/*************************************Coordinate.cpp**************************************************/
#include "Coordinate.h"
Coordinate::Coordinate(int x,int y)
{
	m_iX = x;
	m_iY = y;
}

ostream & operator<<(ostream &out,const Coordinate &coordinate)
{
	out << "横坐标："<<coordinate.m_iX << endl;
	out << "纵坐标："<<coordinate.m_iY << endl;
	return out;
}
/***********************************demo.cpp*************************************/
#include<iostream>
#include"MyStack.h"
#include"Coordinate.h"
using namespace std;

int main(void)
{
	MyStack<Coordinate> *p = new MyStack<Coordinate>(4);

	Coordinate c1(1,2);
	Coordinate c2(3,4);
	Coordinate c3(5,6);
	Coordinate c4(7,8);

	p->push(c1);
	p->push(c2);
	p->push(c3);
	p->push(c4);
	
	p->stackTraverse(true);

	//cout << "删除" << endl;

	//char e,e1;
	//p->pop(e);
	//p->pop(e1);
	//p->stackTraverse();
	//p->clearStack();
	//cout << "栈当前长度:" << p->stackLength() << endl;
	
	system("pause");
	return 0;
	/********************************************
	*********************进制转换****************
	********************************************/
	/*char num[30] = "0123456789ABCDEF";
	MyStack<int> *pStack = new MyStack<int>(30);
	int mod = 0;
	int N = 156;
	while (N != 0)
	{
		mod = N % HEX;
		pStack->push(mod);
		N = N / HEX;		
	}
	while (!pStack->stackEmpty())
	{
		int elem;
		pStack->pop(elem);
		cout << num[elem];
	}
	delete pStack;
	pStack = NULL;
	system("pause");
	return 0;*/

	/**************************************************************
	***********************括号匹配********************************
	****************************************************************/
	/*MyStack<char> *pStack1 = new MyStack<char>(30);
	MyStack<char> *pStackNeed = new MyStack<char>(30);

	char str[]="[[[()]()]]";
	char currentNeed=0;
	for (int i=0;i<strlen(str);i++)
	{
		if (str[i] != currentNeed)
		{
			pStack1->push(str[i]);
			switch(str[i])
			{
			case '[':
				if (currentNeed != 0)
				{
					pStackNeed->push(currentNeed);
				}
				currentNeed = ']';
			break;
			case'(':			
				if (currentNeed != 0)
				{
					pStackNeed->push(currentNeed);
				}
				currentNeed = ')';
			break;
			default:
			cout << "字符串匹配不成功" << endl;
			system("pause");
			return 0;
			}
	   }
		else 
		{	
				char elem;
				pStack1->pop(elem);
				if (!pStackNeed->pop(currentNeed))
				{
					currentNeed = 0;
				}	
		}
	}
	if(pStack1->stackEmpty())
	{
		cout << "字符串括号匹配" << endl;
    }
	else
	{
		cout << "字符串括号不匹配" << endl;
	}

	
	delete pStackNeed;
	pStackNeed = NULL;
	delete pStack1;
	pStack1 = NULL;

	system("pause");
	return 0;*/
}