introduction to algorithms 菜鳥筆記 stack

//author:yydrewdrew

 

#define ERROR -1

template <class T>
struct snode
{ 
 snode *next;
 T value;
};

 

 

template <class T>
class stack
{
public:
 explicit stack();
 void push(const T &t);
 T pop();
 stack(const stack<T> &obj);
 bool empty()const;
 void clear();
 stack<T> &operator = (const stack<T> &obj);
 bool operator == (const stack<T> &obj)const;
 bool operator != (const stack<T> &obj)const;
 virtual ~stack();
private:
 void Destory();
 size_t number;
 snode<T> *top;
};

template<class T>
stack<T> &stack<T>::operator = (const stack<T> &obj)
{
 if (this != &obj)
 {
  if (obj.top == NULL)
  {
   Destory();
   top = NULL;
   number = 0;
  }
  else
  {
   snode<T> *p = new snode<T>;
   snode<T> *p_ = obj.top;
   p->value = p_->value;
   p->next = NULL;
   snode<T> *_top = p;
   while (p_->next != NULL)
   {
    p_ = p_->next;
    p->next = new snode<T>;
    p->next->value = p_->value;
    p->next->next = NULL;
    p = p->next;
   }
   Destory();
   top = _top;
   number = obj.number;
  }
 }
 return *this;
}

template <class T>
stack<T>::stack<T>():number(0),top(NULL){}

template<class T>
bool stack<T>::operator == (const stack<T> &obj)const
{
 if (number != obj.number)
 {
  return false;
 }
 bool is = true;
 snode<T> *p = top;
 snode<T> *_p = obj.top;
 while (p != NULL && _p != NULL)
 {
  if (p->value != _p->value)
  {
   is = false;
   break;
  }
  p = p->next;
  _p = _p->next;
 }
 return is;
}

template<class T>
void stack<T>::Destory()
{
 while (top != NULL)
 {
  snode<T> *_p = top->next;
  delete top;
  top = _p;
 }
 number = 0;
}

template<class T>
bool stack<T>::operator != (const stack<T> &obj)const
{
 if (number != obj.number)
 {
  return true;
 }
 bool is = false;
 snode<T> *p = top;
 snode<T> *_p = obj.top;
 while (p != NULL && _p != NULL)
 {
  if (p->value != _p->value)
  {
   is = true;
   break;
  }
  p = p->next;
  _p = _p->next;
 }
 return is;
}

template <class T>
void stack<T>::push(const T& t)
{
 if (number == 0)
 {
  top = new snode<T>;
  top->value = t;
  top->next = NULL;
  ++number;
  return;
 }
 snode<T> *ptem = new snode<T>;
 ptem->value = t;
 ptem->next = top;
 ++number;
 top = ptem;
}

template <class T>
T stack<T>::pop()
{
 if (!number)
 {
  throw ERROR;
 }
 snode<T> *p_tem = top;
 top = top->next;
 T _t = p_tem->value;
 delete p_tem;
 --number;
 return _t;
}

template<class T>
stack<T>::~stack<T>()
{
 Destory();
}

template<class T>
stack<T>::stack<T>(const stack& obj)
{
 if (obj.top == NULL)
 {
  top = NULL;
  number = 0;
 }
 else
 {
  snode<T> *p = new snode<T>;
  snode<T> *p_ = obj.top;
  p->value = p_->value;
  p->next = NULL;
  top = p;
  number = obj.number;
  while (p_->next != NULL)
  {
   p_ = p_->next;
   p->next = new snode<T>;
   p->next->value = p_->value;
   p->next->next = NULL;
   p = p->next;
  }
 }
}

template <class T>
bool stack<T>::empty()const
{
 return (0 == number);
}

template <class T>
void stack<T>::clear()
{
 Destory();
}