C++模板实现 循环链表的基本算法 《数据结构C++版》 北京科海

/*
Filename：CircleList.h
Description: About the circular list algorithm definition.
date: November 7, 2012
*/

#ifndef CIRCLELIST_H
#define CIRCLELIST_H

#include <iostream>
using namespace std;

template<class T> class CircleList;

template<class T>
class LNode
{
	friend class CircleList<T>;
public:
	LNode(const T &item):data(item)
	{
		next = this;
	}

	LNode()
	{
		next = this;
	}

	~LNode()
	{

	}

public:
	void InsertAfter(LNode<T> *p);
	LNode<T>* DeleteAfter();
	LNode<T>* Next() const;
	T GetData() const;
private:
	T data;
	LNode<T> *next;

};


/*******************************************************/
//循环链表类的定义
template<class T>
class CircleList
{
public:
	CircleList()
	{
		head = new LNode<T>;
		head->next = head;
	}

	~CircleList()
	{
		Empty();
		delete head;
	}

public:
	void Empty(); //清空数据域结点
	void AddToHead(T val);//在首节点前插入val
	void AddToTail(T val);//在尾部插入val
	LNode<T>* GetNode(T val);//查找数据域val的结点
	LNode<T>* GetPriorNode(T val);//得到数据域val的前驱结点
	LNode<T>* GetAfterNode(T val);
	void InsertAfter(LNode<T> *node, T val);//在node后插入数据域为val的结点
	void InsertBefore(LNode<T> *node, T val);
	void DeleteNode(T val);

public:
	int Length();
	int IsEmpty();
	int IsIn(T val); //查找val是否在链表中
	void Print();

private:
	LNode<T>* Tail();
	LNode<T> *head;
};


/*******************************************************/
//类LNode的实现
template<class T>
void LNode<T>::InsertAfter(LNode<T> *p)
{
	p->next = next;
	next = p;
}

template<class T>
LNode<T>* LNode<T>::DeleteAfter()
{
	LNode<T> *tempPtr = next;

	if (next == this)
	{
		return NULL;
	}
	next = tempPtr->next;
	return tempPtr;
}

template<class T>
LNode<T>* LNode<T>::Next() const
{
	return next;
}

template<class T>
T LNode<T>::GetData() const
{
	return data;
}

/*******************************************************/
//类CircleList的实现

template<class T>
void CircleList<T>::Empty()
{
	if (head == head->next)
	{
		return;
	}

	LNode<T> *tempNode = head->next;
	LNode<T> *delNode = NULL;

	while(tempNode != head)
	{
		delNode = tempNode;
		head->next = tempNode->next;
		tempNode = tempNode->next;
		delete delNode;
	}
}


template<class T>
void CircleList<T>::AddToHead(T val)
{
	LNode<T> *newNode = new LNode<T>(val);
	newNode->next = head->next;
	head->next = newNode;
}


template<class T>
void CircleList<T>::AddToTail(T val)
{
	LNode<T> *newNode = new LNode<T>(val);
	newNode->next = head;
	Tail()->next = newNode;
}

template<class T>
LNode<T>* CircleList<T>::GetNode(T val)
{
	if (IsEmpty())
	{
		return NULL;
	}

	LNode<T> *tempNode = head->next;

	while (tempNode != head)
	{
		if (tempNode->data == val)
		{
			return tempNode;
		}
		tempNode = tempNode->next;
	}

	return NULL;
}


template<class T>
LNode<T>* CircleList<T>::GetPriorNode(T val)
{
	LNode<T> *tempNode = head;

	while (tempNode->next != head)
	{
		if (tempNode->next->data == val)
		{
			return tempNode;
		}
		
		tempNode = tempNode->next;
	}

	return NULL;
}


template<class T>
LNode<T>* CircleList<T>::GetAfterNode(T val)
{
	LNode<T> *tempNode = head;

	while (tempNode->next != head)
	{
		if (tempNode->next->data == val)
		{
			return tempNode->next->next;
		}

		tempNode = tempNode->next;
	}

	return NULL;
}


template<class T>
void CircleList<T>::InsertAfter(LNode<T> *node, T val)
{
	LNode<T> *newNode = new LNode<T>(val);
	newNode->next = node->next;
	node->next = newNode;
}


template<class T>
void CircleList<T>::InsertBefore(LNode<T> *node, T val)
{
	if (node == NULL)
	{
		return;
	}

	LNode<T> *before = GetPriorNode(node->data);
	
	if (before == NULL)
	{
		return;
	}

	LNode<T> *newNode = new LNode<T>(val);
	newNode->next = node;
	before->next = newNode;
}

template<class T>
void CircleList<T>::DeleteNode(T val)
{
	if (IsIn(val))
	{
		LNode<T> *tempNode = GetNode(val);
		LNode<T> *priNode = GetPriorNode(val);
		priNode->next = tempNode->next;
		delete tempNode;
	}

	return;
}


template<class T>
int CircleList<T>::Length()
{
	int nlen = 0;
	LNode<T> *tempNode = head->next;

	while (tempNode != head)
	{
		nlen++;
		tempNode = tempNode->next;
	}

	return nlen;
}


template<class T>
int CircleList<T>::IsEmpty()
{
	if (head == head->next)
	{
		return 1;
	}
	else
	{
		return 0;
	}

}


template<class T>
int CircleList<T>::IsIn(T val)
{
	LNode<T> *tempNode = head->next;

	while (tempNode != head)
	{
		if (tempNode->data == val)
		{
			return 1;
		}

		tempNode = tempNode->next;
	}

	return 0;
}


template<class T>
void CircleList<T>::Print()
{
	cout << "共有" << Length() <<"个结点\n";
	LNode<T> *tempNode = head->next;

	while (tempNode != head)
	{
		cout << tempNode->data << " ";
		tempNode = tempNode->next;
	}

	cout << endl;

}


template<class T>
LNode<T>* CircleList<T>::Tail()
{
	LNode<T> *tempNode = head;

	while (tempNode->next != head)
	{
		tempNode = tempNode->next;
	}

	return tempNode;
}

#endif
 
 
//测试

#include "CircleList.h"

int main()
{
	CircleList<int> ls;
	ls.AddToHead(1);
	ls.AddToHead(2);
	ls.AddToHead(3);
	ls.Print();
	cout << "----------------------------"  << endl;

	ls.AddToTail(0);
	ls.AddToTail(100);
	ls.Print();
	cout << "----------------------------"  << endl;

	LNode<int> *addrNode = ls.GetNode(0);
	LNode<int> *priNode = ls.GetPriorNode(0);
	LNode<int> *aftNode = ls.GetAfterNode(0);
	cout << "val=0存储地址：" << addrNode << endl;
	cout << "val=0的前驱存储地址：" << priNode << " " << priNode->GetData() << endl;
	cout << "val=0的后继存储地址：" << aftNode << " " << aftNode->GetData() << endl;
	cout << "----------------------------"  << endl;

	ls.InsertAfter(priNode, 18);
	ls.InsertBefore(aftNode, 19);
	ls.Print();
	cout << "----------------------------"  << endl;

	ls.DeleteNode(18);
	ls.Print();
	cout << "----------------------------"  << endl;

	ls.Empty();
	ls.Print();
	cout << "----------------------------"  << endl;

	system("pause");
	return 0;
}