STL 之 List 模板类实现与应用

节点模板类实现

#ifndef __MY_NODE_H__
#define __MY_NODE_H__

template <class T>
class Node
{
public:
	T data;
	Node(const T& item, Node<T>* ptrnext = NULL);
	void insertAfter(Node<T> *p);
	Node<T>* deleteAfter(void);
	Node<T> *nextNode(void) const;

private:
	Node<T>* next;
};

template <class T>
Node<T>::Node(const T& item, Node<T>* ptrnext /* = NULL */) :
	data(item),
	next(ptrnext)
{ }

//返回私有指针成员
template <class T>
Node<T>* Node<T>::nextNode(void) const
{
	return next;
}

//在当前节点之后插入一个节点p
template <class T>
void Node<T>::insertAfter(Node<T> *p)
{
	p->next = next; //p节点指针域指向当前节点的后继节点
	next = p;		//当前节点的指针域指向p
}

//删除当前节点的后继节点，并返回其地址
template <class T>
Node<T> *Node<T>::deleteAfter(void)
{
	Node<T>* tempPtr = next;	//将欲删除的节点地址存储到tempPtr
	if( !next )				//如果当前节点没有后继节点，则返回NULL
		return NULL;
	next = tempPtr->next;	//使当前节点的指针域指向tempPtr的后继节点
	return tempPtr;			//返回被删除的节点的地址
}

#endif //__MY_NODE_H__

链表类实现

#ifndef __MY_LIST_H__
#define __MY_LIST_H__

#include <iostream>
#include "Node.h"

enum appendNewline
{
	noNewline,
	addNewline
};

//生成节点
template <class T>
Node<T>* getNode(const T& item, Node<T>* nextPtr = NULL)
{
	Node<T> *newNode;
	newNode = new Node<T>(item, nextPtr);
	if(newNode == NULL)
	{
		cerr<<"Memory allocation failure!"<<endl;
		exit(1);
	}
	return newNode;
}

//输出链表
template <class T>
void printList(Node<T> *head, appendNewline addnl = noNewline)
{
	Node<T>* currPtr = head;
	while (currPtr != NULL)
	{
		if (addnl == addNewline)
			cout<<currPtr->data<<endl;
		else
			cout<<currPtr->data<<" ";
		currPtr = currPtr->nextNode();
	}
}

//查找节点
template <class T>
int find(Node<T>* head, T& item, Node<T>* &prevPtr)
{
	Node<T>* currPtr = head;
	prevPtr = NULL;
	while (currPtr != NULL)
	{
		if (currPtr->data == item)
			return 1;
		prevPtr = currPtr;
		currPtr = currPtr->nextNode();
	}
	return 0;
}

//在表头插入节点
template <class T>
void insertFront(Node<T>* &head, T item)
{
	head = getNode(item, head);
}

//在表尾插入节点
template <class T>
void insertRear(Node<T>* &head, const T& item)
{
	Node<T>* newNode, *currPtr = head;
	if (currPtr == NULL)
		insertFront(head,item);
	else
	{
		while (currPtr->nextNode() != NULL)
			currPtr = currPtr->nextNode();
		newNode = getNode(item);
		currPtr->insertAfter(newNode);
	}
}

//删除链表的第一个节点
template <class T>
void deleteFront(Node<T>* &head)
{
	Node<T> *p = head;
	if (head != NULL)
	{
		head = head->nextNode();
		delete p;
	}
}

//删除链表中第一个数据域等于key的节点
template <class T>
void deleteKey(Node<T>* &head, T key)
{
	Node<T> *currPtr = head, *prevPtr = NULL;
	if(currPtr == NULL)
		return;
	while (currPtr != NULL && currPtr->data != key)
	{
		prevPtr = currPtr;
		currPtr = currPtr->nextNode();
	}
	if(currPtr != NULL)
	{
		if(prevPtr == NULL)
			head = head->nextNode();
		else
			prevPtr->deleteAfter();
		delete currPtr;
	}
}

//在有序链表中插入一个节点
template <class T>
void insertOrder(Node<T>* &head, T item)
{
	Node<T>* currPtr, *prevPtr, *newNode;
	prevPtr = NULL;
	currPtr = head;
	while (currPtr != NULL)
	{
		if (item < currPtr->data)
			break;
		prevPtr = currPtr;
		currPtr = currPtr->nextNode();
	}
	if(prevPtr == NULL) 
		insertFront(head, item);
	else
	{
		newNode = getNode(item);
		prevPtr->insertAfter(newNode);
	}
};

//清空链表-删除链表中的所有节点
template <class T>
void clearList(Node<T>* &head)
{
	Node<T>* currPtr, *nextPtr;
	currPtr = head;
	while (currPtr != NULL)
	{
		nextPtr = currPtr->nextNode();
		delete currPtr;
		currPtr = nextPtr;
	}
	head = NULL;
}

#endif //__MY_LIST_H__

应用实例

#include "Node.h"
#include "MyList.h"

int _tmain(int argc, _TCHAR* argv[])
{
	Node<int>* head = NULL, *prevPtr = NULL, *delPtr = NULL;
	int i, key, item;
	for (i = 0; i < 10; i++)
	{
		cin>>item;
		insertFront(head, item);
	}
	cout<<"List:";
	printList(head, noNewline);
	cout<<endl;
	cout<<"请输入一个需要删除的整数：";
	cin>>key;
	prevPtr = head;
	while (find(head, key, prevPtr) != NULL)
	{
		if (prevPtr == NULL)
			head = head->nextNode();
		else
			delPtr = prevPtr->deleteAfter();
		delete delPtr;
	}
	cout<<"List:";
	printList(head, noNewline);
	cout<<endl;
	clearList(head);

	return 0;
}