introduction to algorithms 菜鸟笔记 slist

 //author:yydrewdrew

#define ERROR -1

 

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

 

 

template <class T>
class slist
{
public:
 explicit slist(const T &t,size_t num);
 explicit slist();
 explicit slist(const T *p,size_t num);
 T *Insert(const T& t,uint pos);
 T Delete(uint pos);
 size_t size()const;
 void clear();
 slist(const slist<T>& obj);
 slist<T> &operator = (const slist<T> & obj);
 bool operator == (const slist<T> &obj)const;
 bool operator != (const slist<T> &obj)const;
 T &operator[](uint pos);
 virtual ~slist();
private:
 void Destory();
 size_t number;
 snode<T> *head;
};

template <class T>
slist<T>::slist<T>(const T &t,size_t num)
{
 if (num <= 0)
 {
  head = NULL;
  number = 0;
 }
 else
 {
  head = new snode<T>;
  head->value = t;
  head->next = NULL;
  snode<T> *p = head;
  number = num;
  while(--num)
  {
   p->next = new snode<T>;
   p->next->value = t;
   p = p->next;
   p->next = NULL;
  }
 }
}

template<class T>
slist<T> &slist<T>::operator = (const slist<T> &obj)
{
 if (this != &obj)
 {
  if (obj.head == NULL)
  {
   Destory();
   head = NULL;
   number = 0;
  }
  else
  {
   snode<T> *p = new snode<T>;
   snode<T> *p_ = obj.head;
   p->value = p_->value;
   p->next = NULL;
   snode<T> *_head = p;
   uint _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;
   }
   Destory();
   head = _head;
   number = _number;
  }
 }
 return *this;
}

template <class T>
slist<T>::slist<T>():number(0),head(NULL){}

template<class T>
bool slist<T>::operator == (const slist<T> &obj)const
{
 if (number != obj.number)
 {
  return false;
 }
 bool is = true;
 snode<T> *p = head;
 snode<T> *_p = obj.head;
 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 slist<T>::Destory()
{
 while (head != NULL)
 {
  snode<T> *_p = head->next;
  delete head;
  head = _p;
 }
 number = 0;
}

template <class T>
T *slist<T>::Insert(const T& t,uint pos)
{
 if (pos > number)
 {
  return NULL;
 }
 if (number == 0)
 {
  head = new snode<T>;
  head->value = t;
  head->next = NULL;
  ++number;
  return &head->value;
 }
 snode<T> *p = head;
 while(pos--)
 {
  p = p->next;
 }
 snode<T> *ptem = new snode<T>;
 ptem->value = t;
 ptem->next = p->next;
 p->next = ptem;
 ++number;
 return &ptem->value;
}

template<class T>
T &slist<T>::operator[](uint pos)
{
 if (pos < 0 || pos > number - 1)
 {
  throw ERROR;
 }
 if (pos == 0)
 {
  return head->value;
 }
 snode<T> *p = head;
 while (--pos)
 {
  p = p->next;
 }
 return p->next->value;
}

template <class T>
T slist<T>::Delete(const uint pos)
{
 if (pos < 0 || pos >= number)
 {
  throw ERROR;
 }
 if (pos == 0)
 {
  number = 0;
  T t_tem = head->value;
  delete head;
  head = NULL;
  return t_tem;
 }
 node<T> *p = head;
 while (--pos)
 {
  p = p->next;
 }
 T _t = p->next->value;
 snode<T> *_p = p->next;
 p->next = p->next->next;
 delete _p;
 --number;
 return _t;
}

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

template<class T>
slist<T>::slist<T>(const slist& obj)
{
 if (obj.head == NULL)
 {
  head = NULL;
  number = 0;
 }
 else
 {
  snode<T> *p = new snode<T>;
  snode<T> *p_ = obj.head;
  p->value = p_->value;
  p->next = NULL;
  head = 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>
slist<T>::slist<T>(const T *p,size_t num)
{
 if (p == NULL || num <=0)
 {
  head == NULL;
  number = 0;
 }
 else
 {
  number = 1;
  head = new snode<T>;
  head->value = p[0];
  head->next = NULL;
  snode<T> *_p = head;
  while (number < num)
  {
   _p->next = new snode<T>;
   _p->next->value = p[number];
   _p->next->next = NULL;
   _p = _p->next;
   ++number;
  }
 }
}

template <class T>
size_t slist<T>::size()const
{
 return number;
}

template <class T>
bool slist<T>::operator != (const slist<T> &obj)const
{
 if (number != obj.number)
 {
  return true;
 }
 bool is = false;
 snode<T> *p = head;
 snode<T> *_p = obj.head;
 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 slist<T>::clear()
{
 Destory();
}