链接栈（Link Stack）———— 栈的链接实现

在栈的实现上，采用的是连续分配的数组。这样的栈结构有一个缺陷，即需要大片连续的存储空间。栈(Stack)——后进先出（LIFO）的数据结构（Data Structures）

利用非连续空间的方式是链接。

而以链接方式实现的栈就叫做链接栈或者栈的链接实现。在一个链接栈的结构里，记录之间不一定需要在物理储存空间上相连。每条记录除了存放数据项外，还存放一个指针，用来指向链接栈里的下一条记录。而其所指出的操作类型和数量与连续栈完全一样。

类的定义层面来看，链接栈与连续栈没有什么区别，唯一的不同在数据成员上。连续栈的数据成员为一个数组，链接栈的数据成员则是一个栈头指针而已。

下面是链接栈的类定义。

//Link_Stack in C++
#include
using namespace std;
typedef double stackEntry;

const int overflow = 1;										//返回编码
const int underflow = 2;
const int success = 0;

struct Node
{
	stackEntry data;
	Node * next;
};

class link_stack
{
public:
	link_stack()											//构建函数，初始化一个空栈
	{
		top_node = NULL;
	}
	bool link_stack::empty() const							//判断栈是否为空
	{
		if (top_node != NULL)
			return false;
		return true;
	}

	int link_stack::push(const stackEntry &item)			//将元素item压入栈顶（入栈操作）
	{
		Node * new_top = new Node;							//为元素item构建新的节点，该节点指向原来的栈顶元素

		if (new_top == NULL)
			return overflow;
		new_top->data = item;
		new_top->next = top_node;
		top_node = new_top;
		return success;
	}

	int link_stack::pop()									//如果栈为非空，弹出栈顶元素；否则返回下溢
	{
		Node * old_top = top_node;
		if (top_node == NULL)
			return underflow;
		top_node = old_top->next;
		delete old_top;
		return success;
	}

	int link_stack::top(stackEntry &item) const				//将栈顶元素复制到item里
	{
		if (top_node == NULL)
			return underflow;
		item = top_node->data;
		return success;
	}

	void link_stack::operator = (const link_stack &original)//赋值重载操作
	{
		Node * new_top, *new_copy;
		Node * original_node = original.top_node;
		if (original_node == NULL)
			new_top = NULL;
		else												//逐个复制链接栈的节点
		{
			new_copy = new_top = new Node;
			new_copy->data = new_top->data = original_node->data;
			new_copy->next = new_top->next = NULL;
			while (original_node->next != NULL)
			{
				original_node = original_node->next;
				new_copy->next = new Node;
				new_copy = new_copy->next;
				new_copy->data = original_node->data;
				new_copy->next = NULL;
			}
		}
		while (!empty())									//清除老栈里的元素
			pop();
		top_node = new_top;									//将栈头指向新的链接栈结构
	}

	link_stack::link_stack(const link_stack &original)		//拷贝构造函数，实现深度拷贝
	{
		Node * new_copy;
		Node*original_node = original.top_node;
		if (original_node = NULL)
			top_node = NULL;
		else
		{
			top_node = new_copy = new Node;
			new_copy->data = top_node->data = original_node->data;
			new_copy->next = top_node->next = NULL;
			while (original_node->next != NULL)
			{
				original_node = original_node->next;
				new_copy->next = new Node;
				new_copy = new_copy->next;
				new_copy->next = NULL;
			}
		}
	}

	link_stack::~link_stack()								//链接栈的构析函数
	{
		while (!empty())
			pop();
	}
protected:
	Node * top_node;
};