双向链表

#pragma once
#ifndef DOUBLE_LINK_HXX
#define DOUBLE_LINK_HXX

#include <iostream>
using namespace std;
template<class T>
struct DNode
{
public:
	T value;
	DNode* prev;
	DNode* next;
public:
	DNode() { }
	DNode(T t, DNode* prev, DNode* next) {
		this->value = t;
		this->prev = prev;
		this->next = next;
	}
};

//双向链表基本操作
template<class T>
class CDoubleLink
{
public:
	CDoubleLink();
	~CDoubleLink();

	int size();//大小
	int is_empty();//判断是否为空

	T get(int index);//获取节点
	T get_first();//获取首节点
	T get_last();//获取尾节点

	int insert(int index, T t);
	int insert_first(T t);
	int append_last(T t);

	int del(int index);
	int delete_first();
	int delete_last();

private:
	int count;
	DNode<T>* phead;
private:
	DNode<T>* get_node(int index);
};
template<class T>
inline CDoubleLink<T>::CDoubleLink() :count(0)
{
	// 创建“表头”。注意：表头没有存储数据！
	phead = new DNode<T>();
	phead->prev = phead->next = phead;
	// 设置链表计数为0
	//count = 0;
}

template<class T>
inline CDoubleLink<T>::~CDoubleLink()
{
	// 删除所有的节点
	DNode<T>* ptmp;
	DNode<T>* pnode = phead->next;
	while (pnode != phead)
	{
		ptmp = pnode;
		pnode = pnode->next;
		delete ptmp;
	}
	// 删除"表头"
	delete phead;
	phead = NULL;
}

template<typename T>
inline int CDoubleLink<T>::size()
{
	return count;
}

template<class T>
inline int CDoubleLink<T>::is_empty()
{
	return count == 0;
}
template<class T>
inline T CDoubleLink<T>::get(int index)
{
	return get_node(index)->value;
}

template<class T>
inline T CDoubleLink<T>::get_first()
{
	return get_node(0)->value;
}

template<class T>
inline T CDoubleLink<T>::get_last()
{
	return get_node(count - 1)->value;
}

template<class T>
inline int CDoubleLink<T>::insert(int index, T t)
{
	if (index == 0)
		return insert_first(t);

	DNode<T>* pindex = get_node(index);
	DNode<T>* pnode = new DNode<T>(t, pindex->prev, pindex);
	pindex->prev->next = pnode;
	pindex->prev = pnode;
	count++;

	return 0;
}

template<class T>
inline int CDoubleLink<T>::insert_first(T t)
{
	DNode<T>* pnode = new DNode<T>(t, phead, phead->next);
	phead->next->prev = pnode;
	phead->next = pnode;
	count++;

	return 0;
}

template<class T>
inline int CDoubleLink<T>::append_last(T t)
{
	DNode<T>* pnode = new DNode<T>(t, phead->prev, phead);
	phead->prev->next = pnode;
	phead->prev = pnode;
	count++;

	return 0;
}

template<class T>
inline int CDoubleLink<T>::del(int index)
{
	DNode<T>* pindex = get_node(index);
	pindex->next->prev = pindex->prev;
	pindex->prev->next = pindex->next;
	delete pindex;
	count--;

	return 0;
}

template<class T>
inline int CDoubleLink<T>::delete_first()
{
	return del(0);
}

template<class T>
inline int CDoubleLink<T>::delete_last()
{
	return del(count - 1);
}


template<class T>
inline DNode<T>* CDoubleLink<T>::get_node(int index)
{
	// 判断参数有效性
	if (index < 0 || index >= count)
	{
		cout << "get node failed! the index in out of bound!" << endl;
		return NULL;
	}

	// 正向查找
	if (index <= count / 2)
	{
		int i = 0;
		DNode<T>* pindex = phead->next;
		while (i++ < index) {
			pindex = pindex->next;
		}

		return pindex;
	}

	// 反向查找
	int j = 0;
	int rindex = count - index - 1;
	DNode<T>* prindex = phead->prev;
	while (j++ < rindex) {
		prindex = prindex->prev;
	}

	return prindex;
}

#endif