栈模板

#include <iostream>
#include <string>
#include <stdio.h>
#include <malloc.h>
#include <string.h>
using namespace std;



class aa
{
public:
	int i;
	aa(){this->i=0;}
	aa(int i)
	{
		this->i=i;
	}
	bool operator==(aa& a1)
	{
		return this->i==a1.i;
	}
};

ostream& operator<<(ostream& out,aa& a1)
{
	out<<a1.i;
	return out;
}
template <class T>
class Stack
{
public:
	Stack() //一般无参的构造函数总会把一些成员指针初始化为0
	{
		this->pHead=0;
		this->pNext=0;
		this->pPre=0;
	}
	Stack(T& s)
	{
		this->m_T=s;
		this->pHead=0;
		this->pNext=0;
		this->pPre=0;
	}
	T m_T;
	Stack* pNext;//记录下一个节点的地址
	Stack* pPre;//记录上一个节点的地址
	Stack* pHead;//把头保存在这个结构体中，相当于原来c语言的全局变量的使用
//	但是比全局变量好，因为是栈变量
	void SearchAll( );
	int Search( T tFind);
	void Pop( );
	void Push( T& tNewStack);
};


template<class T>
void Stack<T>::SearchAll( ) //这个函数是全局函数 ，它不同于位于class Stack 内部的SearchAll这个成员函数
{
	Stack<T>* pStack=this->pHead;
	/*********************************
	如何遍历？应该顺着第一个节点的pNext持续找到下一个，并进行输出，直到遇到pNext==0为止
	**********************************/
	Stack<T>* pHead=pStack;
	if (pStack==NULL) 
	{
		printf("null link table!\n");
		return;
	}
	while(1)
	{
		//原来的c语言的方式已经不能适应c++的模板类输出了
		cout<<pStack->m_T<<endl;
		if (pStack->pNext==pHead) break; //当运行到最后一个结点的时候，将不会打印
		//我们还需要做到的就是顺着pNext不断的改变pStack的位置
		pStack=pStack->pNext;
	}

}
template <class T>
int Stack<T>::Search( T tFind)
{
	Stack<T>* pStack=this->pHead;
	/**********************************/
	/*如果找到某一个节点，则报告它的ID*/
	/*如果没有找到某一个节点，则报告没有找到*/
	/*返回值：
	/*       1 表示成功找到
	/*       -1 表示没有找到
	/**********************************/
	Stack<T>* pHead=pStack;
	while(1)
	{
		if (pStack->m_T==tFind) 
		{
			printf("find this node!\n");
			return 1;
		}
		//我们需要判断的是跳出点
		if (pStack->pNext==pHead) break; //当运行到起始节点的时候跳出
		//我们还需要做到的就是顺着pNext不断的改变pStack的位置
		pStack=pStack->pNext;
	}
	printf("don't find this node!\n");
	return -1;
}

template<class T>
void Stack<T>::Pop( )
{
	 Stack<T>* pStack=this->pHead;
	//找到最后一个节点
	//执行删除操作

	 Stack<T> *pHead=pStack;//把pHead记录下来	
	//特殊处理
	//如何判断只有一个节点	
	if (pStack->pNext==pStack)
	{
		pHead=0;
		free(pStack);
		this->pHead=pHead;
	}

	
	//需要把pStack指向尾巴
	pStack=pHead->pPre;//头指针的pPre就是尾巴

	//1把当前节点的上一个节点指向当前节点的下一个节点
	pStack->pPre->pNext=pStack->pNext;
	//2 把当前节点的下一个节点的pPre指向当前节点的上一个节点
	pStack->pNext->pPre=pStack->pPre;

	free(pStack);//这里的顺序非常重要

	printf("pop stack succeed!\n");
	
	this->pHead=pHead;
}



template<class T>
void Stack<T>::Push( T& tNewStack)
{
	 Stack<T>* pStack=this->pHead;
	//增加在原来的插入的基础上，不需要查找点了，相当于对头节点进行插入
	//只是头指针不要再变化而已
	 Stack<T> *pHead=pStack;//把pHead记录下来
	 Stack<T> *pNew=NULL;//用于创建新的结点位置记录
	char ifFind=0;//表示没有找到

	//特殊处理如下：
	//如果链表是空的，则直接创建新的节点，并把pHead给这个新的节点
	if (pStack==NULL)
	{
		//1 建立新的节点
		pNew=new Stack<T>;

		pNew->m_T=tNewStack;//把原来的具体类型的值修改为T的值
		
		pNew->pNext=pNew;//并把新的节点的pNext置为NULL
		pNew->pPre=pNew;
		pHead=pNew;
		printf("push stack succeed!\n");
		this->pHead=pHead;
		return;
	}
	
	//1 建立新的节点
	pNew=new Stack<T>;

	pNew->m_T=tNewStack;//把原来具体类型的值修改为T的值
	
	pNew->pNext=pNew;//把新的节点的上下指针分别指向自己
	pNew->pPre=pNew;

	//1 把当前节点的上一个的pNext指向新的节点
	pStack->pPre->pNext=pNew;
	//2 把新的节点的pNext指向当前节点
	pNew->pNext=pStack;
	//3 把新的节点的pPre指向当前节点的上一个节点
	pNew->pPre=pStack->pPre;
	//4 把当前节点的pPre指向新的节点
	pStack->pPre=pNew;

	
	printf("push stack succeed!\n");
	this->pHead=pHead;
}

int main(int argc, char* argv[])
{
	//下面就要用这个万能的栈了，泛性栈，模板栈
	Stack<aa> s;
	aa i(1),j(2),k(3);
	s.Push(i);
	s.Push(j);
	s.Push(k);
	s.SearchAll();
	s.Search(j);
	return 0;
}