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

};