introduction to algorithms 菜鸟笔记 list

//author:yydrewdrew

 

#define ERROR -1

 

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

 

 

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

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

template<class T>
list<T> &list<T>::operator = (const list<T> &obj)
{
 if (this != &obj)
 {
  if (obj.head == NULL)
  {
   Destory();
   head = NULL;
   number = 0;
  }
  else
  {
   node<T> *p = new node<T>;
   node<T> *p_ = obj.head;
   p->value = p_->value;
   p->prev = NULL;
   p->next = NULL;
   node<T> *_head = p;
   while (p_->next != NULL)
   {
    p_ = p_->next;
    p->next = new node<T>;
    p->next->value = p_->value;
    p->next->prev = p;
    p->next->next = NULL;
    p = p->next;
   }
   Destory();
   head = _head;
   number = obj.number;
  }
 }
 return *this;
}

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

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

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

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

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

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

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

template<class T>
list<T>::list<T>(const T *p,const size_t num)
{
 if (p == NULL || num <=0)
 {
  head == NULL;
  number = 0;
 }
 else
 {
  number = 1;
  head = new node<T>;
  head->value = p[0];
  head->next = NULL;
  head->prev = NULL;
  node<T> *_p = head;
  while (number < num)
  {
   _p->next = new node<T>;
   _p->next->value = p[number];
   _p->next->prev = _p;
   _p->next->next = NULL;
   _p = _p->next;
   ++number;
  }
 }
}

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

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