栈模板的链表实现（包含头结点），实现了栈的压入，栈的弹出，返回栈顶元素，排序等操作

//头文件
#ifndef STACKLIST_H
#define STACKLIST_H

#include
#include
#include
using namespace std;

template
class LinkNode{
	//该类的作用是作为节点
public:
	T data;
	LinkNode* link;
	LinkNode(){
		//默认构造函数
	}
	LinkNode(T data, LinkNode* str = NULL, LinkNode* ptr = NULL):data(data),link(str){
		
	}
};
template
class StackList{

private:
	LinkNode* head;
	LinkNode* topOfStack;//栈顶指针,控制数据的压入和数据的出栈操作,每次在有节点发生变化时，都会改变此值
	static int Count;

public:
	StackList();
	StackList(const StackList& str);//拷贝构造函数
	~StackList();
	void Clear();
	void Push(const T& value);
	void Pop();
	bool isEmpty()const;
	//bool isFull()const;//链表形式的栈（除非在头结点中的数据域给出栈的最大长度，但这个实例模板中没有给出最大长度）不存在满栈情况
	T TopAndPop();
	int Length();
	void Sort();
	void TopOfStack();//返回栈顶指针
	const T& Top()const;
	void Print();
	//const StackList& operator=(const StackList& str);
};
template
void StackList::Print()
{
	vectorvec;
	LinkNode* p = head;
	p = p->link;
	while (p)
	{
		vec.push_back(p->data);
		p = p->link;
	}
	vec.reserve(Length());
	vector::iterator iter = vec.begin();
	for (; iter != vec.end(); iter++)
	{
		cout << *iter << " ";
	}
	cout << endl;
}
//template
//const StackList& StackList::operator=(const StackList& str)
//{
//	if (this != &str)
//	{
//		Clear();
//		if (str.isEmpty())
//			return *this;
//		LinkNode* p = str.head;
//		p = p->link;//应为该链表含有头结点，第一个节点内数据项中不含数据，所以直接指向下一个节点
//		LinkNode* ptr = new LinkNode();
//		head = ptr;
//		while (p)
//		{
//			ptr->link = new LinkNode(p->data);
//			p = p->link;
//			ptr = ptr->link;
//			ptr->link = NULL;
//		}
//	}
//	return *this;
//}

template
int StackList::Count = 0;//Count用来记录当前节点的个数

template
StackList::StackList()
{
	//默认构造函数，只生成一个头结点(该链表形式的栈具有头结点，且头节点中数据项为空)
	head = new LinkNode();
	head->link = NULL;
	topOfStack = head;
	Count++;
}
template
StackList::StackList(const StackList& str)
{
	int count = str.Length();
	LinkNode* p = str.head;
	head = new LinkNode();//首先生成一个头结点
	LinkNode* ptr = head;
	while (count)
	{
		ptr->data = p->data;//将数据项复置
		p = p->link;
		ptr->link = new LinkNode();
		ptr = ptr->link;
		ptr->link = NULL;
		count--;
	}
	this.Count = str.Clear;
	topOfHead = ptr;
}

template
StackList::~StackList()
{
	//将所有的空间都释放，和Clear()具有相同的操作
	Clear();
}

template
void StackList::Clear()
{
	LinkNode* p = head;
	while (p)
	{
		p = p->link;
		delete head;
		head = p;
	}
	head = NULL;
	Count = 0;
}

template
void StackList::Push(const T& value)
{
	LinkNode* p = topOfStack;
	p->link = new LinkNode(value);
	p = p->link;
	p->link = NULL;
	Count++;
	topOfStack = p;
}
template
void StackList::Pop()
{
	if (isEmpty())
	{
		return ;
	}
	LinkNode* ptr = head;
	while (!(ptr->link == topOfStack))
	{
		ptr = ptr->link;
	}
	//被删除节点的空间被释放
	LinkNode* str = topOfStack;
	delete str;
	ptr->link = NULL;
	topOfStack = ptr;//topOfStack=ptr的功能与TopOfStack()的功能相同
	//TopOfStack();
	Count--;
}

template
bool StackList::isEmpty()const
{
	if (head == NULL)
		return true;
	else
		return false;
}

template
T StackList::TopAndPop()
{
	T item = Top();
	Pop();
	Count--;
	return item;
}

template
int StackList::Length()
{
	return Count;
}

template
void StackList::Sort()
{
	vectorvec;
	LinkNode* p = head;
	p = p->link;//应为该链表含有头结点，第一个节点内数据项中不含数据，所以直接指向下一个节点
	while (p)
	{
		vec.push_back(p->data);
		p = p->link;
	}
	p = head;
	p = p->link;
	sort(vec.begin(),vec.end());
	for (int i = 0; i < vec.size(); i++)
	{
		p->data = vec[i];
		p = p->link;
	}
}

template
void StackList::TopOfStack()
{
	LinkNode* p = head;
	while (p->link)
	{
		p = p->link;
	}
	topOfStack = p;
}

template
const T& StackList::Top()const
{
	return topOfStack->data;
}


#endif

//主函数
#include"StackList.h"

int main(int argc, char argv[])
{
	StackListlist;
	list.Push(5);
	list.Push(4);
	list.Push(2);
	list.Push(3);
	list.Push(1);
	list.Push(0);
	list.Push(9);
	list.Push(7);
	list.Print();
	int number1 = list.Top();
	cout << number1 << endl;
	list.Sort();
	list.Print();
	int number = list.Top();
	cout << number << endl;
	list.Pop();
	list.Print();
	return 0;
}