C++实现双向链表

多了个前向指针，注意插入删除时候的修改顺序

创建双向节点

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 DoubleLink {
public:
	DoubleLink();
	~DoubleLink();

	int size();
	int isEmpty();

	T get(int index);
	T getFirst();
	T getLast();

	int insert(int index, T t);
	int insertFirst(T t);
	int appendLast(T t);

	int del(int index);
	int delFirst();
	int delLast();
private:
	int count;
	DNode<T>* pHead;
private:
	DNode<T>* getNode(int index);
};

函数实现

template<class T>
DoubleLink<T>::DoubleLink() : count(0)
{
	// 创建表头。注意：表头没有存储数据
	pHead = new DNode<T>();
	pHead->next = NULL;
}

// 析构函数
template<class T>
DoubleLink<T>::~DoubleLink()
{
	// 删除所有结点
	DNode<T>* pTemp;
	DNode<T>* pNode = pHead->next;
	while (pNode != pHead)
	{
		pTemp = pNode;
		pNode = pNode->next;
		delete pTemp;
	}

	// 删除表头
	delete pHead;
	pHead = NULL;

}

// 返回结点数目
template<class T>
int DoubleLink<T>::isEmpty()
{
	return count == 0;
}

// 返回节点数目
template < class T>
int DoubleLink<T>::size()
{
	return count;
}

// 获取index位置的结点
template<class T>
DNode<T>* DoubleLink<T>::getNode(int index)
{
	// 判断参数有效性
	if (index < 0 || index >= count)
	{
		cout << " getNode failed! the index is out of round" << 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;
}

// 获取第index位置的结点的值
template<class T>
T DoubleLink<T>::get(int index)
{
	return getNode(index)->value;
}

// 获取第一个结点的值
template<class T>
T DoubleLink<T>::getLast()
{
	return getNode(count - 1)->value;
}

// 获取最后一个结点的值
template<class T>
T DoubleLink<T>::getFirst()
{
	return getNode(0)->value;
}

// 将结点插入到第index位置之前
template<class T>
int DoubleLink<T>::insert(int index, T t)
{
	if (index == 0)
		return insertFirst(t);

	DNode<T>* pIndex = getNode(index);
	DNode<T>* pNode = new DNode<T>(t, pIndex->prev, pIndex);
	pIndex->prev->next = pNode;
	pIndex->prev = pNode;
	count++;

	return 0;
}

// 将结点插入到第一个结点处
template<class T>
int DoubleLink<T>::insertFirst(T t)
{
	DNode<T>* pNode = new DNode<T>(t, pHead, pHead->next);   // 构造函数时就已经指定结点的前驱和后继结点了

	// 这里第一个结点的时候需要判断空指针
	if (pHead->next == NULL)
		pHead->prev = pNode;
	else
		pHead->next->prev = pNode;

	pHead->next = pNode;
	count++;

	return 0;
}

// 将结点追加到链表的末尾
template<class T>
int DoubleLink<T>::appendLast(T t)
{
	DNode<T>* pNode = new DNode<T>(t, pHead->prev, pHead);
	pHead->prev->next = pNode;
	pHead->prev = pNode;
	count++;
	return 0;
}

// 删除index位置的结点
template<class T>
int DoubleLink<T>::del(int index)
{
	DNode<T>* pIndex = getNode(index);
	pIndex->next->prev = pIndex->prev;
	pIndex->prev->next = pIndex->next;
	delete pIndex;
	count--;

	return 0;
}

// 删除第一个结点
template<class T>
int DoubleLink<T>::delFirst()
{
	return del(0);
}

// 删除最后一个结点
template<class T>
int DoubleLink<T>::delLast()
{
	return del(count - 1);
}

测试

void intTest() {
	int intArr[4] = { 10,20,30,40 };

	cout << "\n -------------intTest------------" << endl;

	// 创建双向链表
	DoubleLink<int>* pDlinkList = new DoubleLink<int>();

	pDlinkList->insert(0, 20);
	pDlinkList->appendLast(10);
	pDlinkList->insertFirst(30);
	pDlinkList->insert(1, 40);
	pDlinkList->delFirst();

	// 双向链表是否为空
	cout << "isEmpty= " << pDlinkList->isEmpty() << endl;

	// 双向链表的长度
	cout << "size=" << pDlinkList->size() << endl;

	// 打印双向链表的全部数据
	int length = pDlinkList->size();
	for (int i = 0; i < length; i++)
	{
		cout << "pDlinkList(" << i << ")=" << pDlinkList->get(i) << endl;
	}
}

void stringTest()
{
	string sArr[4] = { "ten","tewnty","thirty","forty" };

	cout << "\n------------stringTest-----------" << endl;

	DoubleLink<string>* pDlinkList = new DoubleLink<string>();

	pDlinkList->insert(0, sArr[1]);
	pDlinkList->appendLast(sArr[0]);
	pDlinkList->insertFirst(sArr[2]);


	// 双向链表是否为空
	cout << "isEmpty()=" << pDlinkList->isEmpty() << endl;

	// 双向链表的长度
	cout << "size=" << pDlinkList->size() << endl;

	// 打印双向链表的全部数据
	int length = pDlinkList->size();
	for (int i = 0; i < length; i++)
	{
		cout << "pDlinkList(" << i << ")=" << pDlinkList->get(i) << endl;
	}
}

struct stu
{
	int id;
	char name[20];
};

static stu stuArr[] =
{
	{10,"one"},
	{20,"two"},
	{30,"three"},
	{40,"four"}

};

#define ARR_STU_SIZE ((sizeof(stuArr)) / (sizeof(stuArr[0])))

void objectTest()
{
	cout << "\n------------stringTest-----------" << endl;

	DoubleLink<stu>* pDlinkList = new DoubleLink<stu>();

	pDlinkList->insert(0, stuArr[1]);
	pDlinkList->appendLast(stuArr[0]);
	pDlinkList->insertFirst(stuArr[2]);

	// 双向链表是否为空
	cout << "isEmpty()=" << pDlinkList->isEmpty() << endl;

	// 双向链表的长度
	cout << "size=" << pDlinkList->size() << endl;

	// 打印双向链表的全部数据
	struct stu p;
	int length = pDlinkList->size();
	for (int i = 0; i < length; i++)
	{
		p = pDlinkList->get(i);
		cout << "pDlinkList(" << i << ")=[" << p.id << " ," << p.name << "]" << endl;
	}
}


int main()
{
	intTest();
	stringTest();
	objectTest();
	return 0;
}