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();
}