关于堆栈

堆栈是一种后进先出的数据结构，当你从堆栈中取出一个元素的时候，你得到的是最后进入堆栈的那个元素。堆栈这种数据结构特别适用于那些由多层子任务构成的任务。

堆栈比较常见的用法有1）保存子例程中的返回地址，参数，局部变量。2）用编译器分析语法时保存各种语法元素记号。

动态数组与链表的主要区别为其随机存取性，但因为堆栈上的操作永远集中在数据元素的尾部，所以使用动态数组体现不出它的优势。随着元素的增加，动态数组的大小总要随之调整，这是一种很费时的操作。

typedef struct elementT{
	struct elementT *next;
	void *data;
}element;

int Push(element **stack,void *data);
int Pop(element **stack,void **data);
int CreateStack(element **stack)
{
	*stack=NULL;
	return 1;
}
//不带头结点
int Push(element **stack,void *data)
{
	element *elem;
	elem=(element *)malloc(sizeof(element));
	if(!elem)
		return 0; //这点非常重要
	elem->data=data;
	elem->next=*stack;
	*stack=elem;
	return 1;
}

int Pop(element **stack,void **data)
{
	element *elem;
	if(!(elem=*stack))
		return 0;
	*data=elem->data;
	*stack=elem->next;
	free(elem);
	return 1;
}
int deleteStack(element **stack)
{
	element *elem;
	while(*stack)
	{
		elem=(*stack)->next;
		free(*stack);
		*stack=elem;
	}
	return 1;
}

构造的栈类

class Stack
{
public:
	Stack();
	~Stack();
	void Push(void *data);
	void *Pop();
protected:
	typedef struct elementT{
		struct elementT *next;
		void *data;
	}element;
	element *firstE1;
};

Stack::Stack(){
	firstE1=NULL;
	return;
}
Stack::~Stack(){
	element *elem;
	while(firstE1){
		elem=firstE1->next;
		delete firstE1;
		firstE1=elem;
	}
	return ;
}

void Stack::Push(void *data)
{
	element *elem=new element;
	elem->data=data;
	elem->next=firstE1;
	firstE1=elem;
	return;
}

void *Stack::Pop()
{
	element *popElem=firstE1;
	void *data;
	if(!firstE1)
		throw StackError(E_EMPTY);
	data=firstE1->data;
	firstE1=firstE1->next;
	delete popElem;
	return data;
}