LinkedList泛型链表类

/*************************************************************************
 Copyright   : Free
 Author      : Cheng Haifeng
 Date        : 2017-10-17
 Description : LinkedList
 Environment : RAD Studio XE7
 ************************************************************************ */

/*************************************************************************
 T 的需求
 T 如果为内置类型，无特殊需求。
 T 如果为类或结构体，请重载operator ==和>。
 必要时需重载 operator=，无参构造函数和赋值构造函数。
 ************************************************************************ */
// 节点
template
   
   
    
    
class LinkedNode {
public:
	typedef LinkedNode
    
    
     
     _Node;
	typedef _Node *_Nodeptr;
	T Value; // 数据；如果是头节点则不使用。
	_Nodeptr Next; // 后续节点指针；如果是头节点，则为第一节点指针。
	_Nodeptr Prev; // 前任节点指针；如果是头节点，则为最后节点指针。
}; // LinkedNode 节点结束

template
     
     
      
      
class LinkedList : public LinkedNode
      
      
       
        {
protected:
	typedef LinkedNode
       
       
         ::_Node _Node; typedef LinkedNode 
        
          ::_Node *_Nodeptr; typedef LinkedNode 
         
           ::_Nodeptr& _Nodepref; typedef LinkedList 
          
            *_Listptr; // 申请的节点内存 static _Nodeptr _NewNode(_Nodeptr prev = NULL, _Nodeptr next = NULL) { _Nodeptr node = new _Node; _NextNode(node) = next; _PrevNode(node) = prev; return node; } // 释放节点内存 static void _DelNode(_Nodeptr ptr) { delete ptr; } // 返回节点后续指针的引用 static _Nodepref _NextNode(_Nodeptr ptr) { return ((_Nodepref)(*ptr).Next); } // 返回节点前驱指针的引用 static _Nodepref _PrevNode(_Nodeptr ptr) { return ((_Nodepref)(*ptr).Prev); } // 返回节点数据的引用 static T& _ValueNode(_Nodeptr ptr) { return (*ptr).Value; } // 数据节点数量 int _Count; public: // 迭代器内部类 class Iterator { friend class LinkedList 
           
             ; public: // 构造函数 p - 父节点或父类指针 Iterator(_Listptr p) : Headptr(p), Nodeptr(p) { } // 析构函数 ~Iterator() { } // 移动到第一个元素，返回是否成功。 bool MoveFirst() { Nodeptr = _NextNode(Headptr); return Headptr != Nodeptr; } // 移动到下一节点，返回是否成功。 bool MoveNext() { Nodeptr = _NextNode(Nodeptr); return Headptr != Nodeptr; } T& Value() { return _ValueNode(Nodeptr); } // 删除当前节点，移动前一节点 void Remove() { _Nodeptr Pnode = Nodeptr; if (Pnode != Headptr) { // 头节点就不要删了 Nodeptr = _PrevNode(Nodeptr); _NextNode(_PrevNode(Pnode)) = _NextNode(Pnode); _PrevNode(_NextNode(Pnode)) = _PrevNode(Pnode); _DelNode(Pnode); Headptr->_Count--; } } protected: // 节点指针 _Nodeptr Nodeptr; // 头/尾节点指针，也是父类指针 _Listptr Headptr; }; // 迭代器内部类结束 // 删除节点，并释放节点空间，删除后Iterator失效。 void Remove(T value) { _Nodeptr Pnext; _Nodeptr Pnode = _NextNode(this); while (Pnode != this) { Pnext = _NextNode(Pnode); if (value == _ValueNode(Pnode)) { _NextNode(_PrevNode(Pnode)) = _NextNode(Pnode); _PrevNode(_NextNode(Pnode)) = _PrevNode(Pnode); _DelNode(Pnode); _Count--; } Pnode = Pnext; } } // 删除第一个节点 void RemoveFront() { _Nodeptr Pnode = _NextNode(this); if (Pnode != this) { _NextNode(_PrevNode(Pnode)) = _NextNode(Pnode); _PrevNode(_NextNode(Pnode)) = _PrevNode(Pnode); _DelNode(Pnode); _Count--; } } // 删除最后一个节点 void RemoveBack() { _Nodeptr Pnode = _PrevNode(this); if (Pnode != this) { _NextNode(_PrevNode(Pnode)) = _NextNode(Pnode); _PrevNode(_NextNode(Pnode)) = _PrevNode(Pnode); _DelNode(Pnode); _Count--; } } // 无参构造函数 LinkedList() : LinkedNode 
            
              () { _NextNode(this) = this; _PrevNode(this) = this; _Count = 0; } // 析构函数 ~LinkedList() { Clear(); } // 清空链表 void Clear() { _Nodeptr Pnext; _Nodeptr Pnode = _NextNode(this); while (Pnode != this) { Pnext = _NextNode(Pnode); _DelNode(Pnode); Pnode = Pnext; } _NextNode(this) = this; _PrevNode(this) = this; _Count = 0; } // 检查是否为空 bool Empty() { return _Count == 0; } // 链表大小 - 节点数量 int Count() { return _Count; } // 反转列表 void Reverse() { _Nodeptr Pnode = this; _Nodeptr Pnext; do { Pnext = _NextNode(Pnode); _NextNode(Pnode) = _PrevNode(Pnode); _PrevNode(Pnode) = Pnext; Pnode = Pnext; } while (Pnode != this); } // 冒泡排序 - 当asc=true时，升序排列;false 降序。需重载T的>操作符。 void Sort(bool asc = true) { _Nodeptr tail = this; while (_NextNode(this) != tail) { _Nodeptr n1 = _NextNode(this); // 第一个节点 _Nodeptr n2 = _NextNode(n1); // 第二个节点 while (n2 != tail) { if ((_ValueNode(n1) > _ValueNode(n2)) == asc) { _NextNode(_PrevNode(n1)) = n2; _NextNode(n1) = _NextNode(n2); _NextNode(n2) = n1; _PrevNode(_NextNode(n1)) = n1; _PrevNode(n2) = _PrevNode(n1); _PrevNode(n1) = n2; n2 = _NextNode(n1); } else { n1 = _NextNode(n1); n2 = _NextNode(n2); } } tail = n1; } } // 删除重复节点 void Unique() { _Nodeptr node = _NextNode(this); while (node != this) { _Nodeptr next = _NextNode(node); while (next != this) { if (_ValueNode(node) == _ValueNode(next)) { _Nodeptr pnode = _NextNode(next); _NextNode(_PrevNode(next)) = _NextNode(next); _PrevNode(_NextNode(next)) = _PrevNode(next); _DelNode(next); _Count--; next = pnode; } else { next = _NextNode(next); } } node = _NextNode(node); } } // 在节点前插入数据 void InsertFront(Iterator iter, const T data) { _Nodeptr Pnode = iter.Nodeptr; _Nodeptr Newnode = _NewNode(_PrevNode(Pnode), Pnode); _NextNode(_PrevNode(Pnode)) = Newnode; _PrevNode(Pnode) = Newnode; _ValueNode(Newnode) = data; _Count++; } // 在第一个节点前插入数据 void InsertFront(const T data) { InsertBack(GetIterator(), data); } // 在节点后插入数据 void InsertBack(Iterator iter, const T data) { _Nodeptr Pnode = iter.Nodeptr; _Nodeptr Newnode = _NewNode(Pnode, _NextNode(Pnode)); _PrevNode(_NextNode(Pnode)) = Newnode; _NextNode(Pnode) = Newnode; _ValueNode(Newnode) = data; _Count++; } // 在最后一个节点后插入数据 void InsertBack(const T data) { InsertFront(GetIterator(), data); } // 获得头节点 Iterator GetIterator() { return Iterator(this); } };