双向链表的实现

#include "Node.h"
#include <iostream>
using namespace std;
class LinkedList
{
private:
	int listLength;//链表长度
	bool isEmpty;//记录链表是否为空表
	Node *headNode;
public:
	LinkedList();//构造函数
	int getListLength(){return listLength;}
	void addElem();//向链表中添加元素，表尾
	void printList();//打印链表
	void clearList();//清空链表，即释放所有节点内存
	void addElemToHead(int);//向链表表头添加一个元素
	void addElemToTail(int);//向链表表尾添加一个元素
	Node *getPtr(int index);//返回链表中从表头起第index个元素的指针，0<=index<listLength
	
	void deleteElem1(int index);//删除从表头起第index个元素，
	void deleteElem2(int number);//删除链表中元素为number的所有节点
	void deleteElem3(int number);//删除链表中从表头起第一个等于number的节点
	
	void search(int number);//在链表中查找关键字等于number的节点，并输出其所在位置
	void insertElem(int index,int number);//向链表的第index处插入元素number，

};

//构造函数
LinkedList::LinkedList()//
{
	headNode = new Node;//新节点next和prev为NULL
	listLength = 0;
	isEmpty = true;
}

//向链表中添加元素，表尾
void LinkedList::addElem()
{
	int num;
	char whetherContinue;
	do{
		cout << "please input an elem you want to add to the list：";
		cin >> num;
		if(isEmpty)
		{
			this->headNode->setElem(num);
			this->isEmpty = false;//表不为空
		}
		else{
			Node *tempNode = new Node;
			tempNode->setElem(num);
			if(headNode->getNextPtr()!=NULL)
				headNode->getNextPtr()->setPrev(tempNode);
			tempNode->setNext(headNode->getNextPtr());
			tempNode->setPrev(headNode);
			headNode->setNext(tempNode);
		}
		this->listLength = listLength + 1;//链表长度加一
		cout << "continue to add elem to the list ? (y/n):";
		cin >> whetherContinue;
	}while(whetherContinue=='y'||whetherContinue=='Y');
}

//打印链表
void LinkedList::printList()
{
	if(this->isEmpty)
		cout << "the list is empty." << endl;
	else{
		cout << "the list is :";
		Node *temp = this->headNode;
		while(temp!=NULL)
		{
			cout << " " << temp->getElem();
			temp = temp->getNextPtr();
		}
		cout << endl;
	}
}

//清空链表，即释放所有节点内存,
void LinkedList::clearList()
{
	if(!this->isEmpty)//当表不是空表时进行清空操作
	{
		Node *temp;//删除操作一定是删除一个节点，！！！
		                   //直接删除节点的指针是错误的
		while(headNode!=NULL)
		{
			temp = headNode->getNextPtr();
			delete headNode;
			this->headNode = temp;
		}
		//因为头节点已经清空内存，因此需要新建
		headNode = new Node;
		headNode->setNext(NULL);
		headNode->setPrev(NULL);
		this->isEmpty = true;
		this->listLength = 0;//空表的两个属性
	}
}

//向链表表头添加一个元素
void LinkedList::addElemToHead(int num)
{
	if(this->isEmpty)//如果是空表
	{
		this->headNode->setElem(num);
		isEmpty = false;//表中有元素，不为空
		this->listLength = 1;
	}
	else{
		Node *tempNode = new Node;
		
		tempNode->setElem(this->headNode->getElem());
		this->headNode->setElem(num);
		tempNode->setNext(this->headNode->getNextPtr());
		tempNode->setPrev(this->headNode);
		if(this->headNode->getNextPtr()!=NULL)
			this->headNode->getNextPtr()->setPrev(tempNode);
		this->headNode->setNext(tempNode);
		
		this->listLength = this->listLength + 1;
	}
}

//向链表表尾添加一个元素
void LinkedList::addElemToTail(int num)
{
	if(this->isEmpty)
	{
		headNode->setElem(num);
		this->isEmpty = false;
	}
	else
	{
		Node *tailNode = this->getPtr(listLength);//仔细想想为什么不new一个空间呢，别名！！！
		Node *addedNode = new Node;
		addedNode->setElem(num);
		addedNode->setPrev(tailNode);
		tailNode->setNext(addedNode);
	}
	this->listLength = listLength + 1;
}

//返回链表中从表头起第index个元素的指针，0<index<listLength,以及空表NULL指针
Node *LinkedList::getPtr(int index)//已知index大于0且小于等于listLength，，，
{
	if(this->isEmpty)//空表情况下
		return NULL;
	else{
		int count = 0;
		Node *temp;
		do{
			if(count==0)//赞咯，我真机智
				temp = headNode;
			else
				temp = temp->getNextPtr();
			count++;
		}while(count<index);
		return temp;
	}
}

//删除从表头起第index个元素
void LinkedList::deleteElem1(int index)
{
	if(listLength==0)
		cout << "the list is empty,cann't delete elem." << endl;
	else if(index<=0||index>listLength)
		cout << "the index beyond the range of list,cann't delete elem." << endl;
	else{
		Node *elemNode = this->getPtr(index);
		//链表只有一个节点的情况
		if(elemNode->getPrevPtr()==NULL && elemNode->getNextPtr()==NULL)
		{
			delete headNode;
			headNode = new Node;//新建表头节点
			this->headNode->setNext(NULL);
			headNode->setPrev(NULL);
			this->listLength = 0;
			this->isEmpty = true;
		}
		//elemNode位于表头
		else if(elemNode->getPrevPtr()==NULL&&elemNode->getNextPtr()!=NULL)
		{
			headNode = headNode->getNextPtr();
			headNode->setPrev(NULL);
			delete elemNode;
			listLength = listLength - 1;
		}
		//elemNode位于表尾
		else if(elemNode->getPrevPtr()!=NULL&&elemNode->getNextPtr()==NULL)
		{
			Node *tail = this->getPtr(listLength);
			tail->getPrevPtr()->setNext(NULL);
			delete tail;
			listLength = listLength - 1;
		}
		//elemNode位于表中
		else{
			elemNode->getPrevPtr()->setNext(elemNode->getNextPtr());
			elemNode->getNextPtr()->setPrev(elemNode->getPrevPtr());
			delete elemNode;
			listLength = listLength - 1;
		}
	}
}

//删除链表中元素为number的所有节点
void LinkedList::deleteElem2(int number)
{
	if(isEmpty)
	{	
		cout << "the list is empty." << endl;
		return;
	}
	bool exist = false;
	Node *temp = this->headNode;
	Node *tempNext;
	int length = this->listLength;
	for(int i=1;i<=length;i++)
	{
		tempNext = temp->getNextPtr();
		if(temp->getElem()==number)
		{
			exist = true;
			if(this->listLength==1)//表中只有一个元素，且和number相等
			{	
				delete this->headNode;
				headNode = new Node;//申请新的内存区域
				headNode->setNext(NULL);
				headNode->setPrev(NULL);
				this->isEmpty = true;
			}
			else{//表中有两个或者以上元素时,且temp位于表头
				if(temp->getPrevPtr()==NULL&&temp->getNextPtr()!=NULL)
				{
					delete headNode;
					headNode = tempNext;
					headNode->setPrev(NULL);
				}
				//temp为表尾时
				else if(temp->getPrevPtr()!=NULL&&temp->getNextPtr()==NULL)
				{
					temp->getPrevPtr()->setNext(NULL);
					delete temp;
				}
				else{
					temp->getPrevPtr()->setNext(temp->getNextPtr());
					temp->getNextPtr()->setPrev(temp->getPrevPtr());
					delete temp;
				}
			}
			this->listLength = listLength - 1;
		}
		temp = tempNext;
	}
	if(!exist)//当exist为false时，即表中没有元素和number相等时
		cout << number << " is not in the list." << endl;
	else
		cout << number << " has been deleted from the list." << endl;
}

//删除链表中从表头起第一个等于number的节点
void LinkedList::deleteElem3(int number)
{
	if(isEmpty)
	{	
		cout << "the list is empty." << endl;
		return;
	}
	Node *temp = headNode;
	Node *tempNext;
	int length = listLength;
	for(int i=1;i<=length;i++)
	{
		tempNext = temp->getNextPtr();
		if(temp->getElem()==number)
		{
			if(listLength==1)
			{
				delete headNode;
				headNode = new Node;//申请节点内存空间
				headNode->setNext(NULL);
				headNode->setPrev(NULL);
				this->isEmpty = true;
				listLength = 0;
			}
			else{//表中有两个或两个以上节点，
				//temp为表头时，
				if(temp->getPrevPtr()==NULL&&temp->getNextPtr()!=NULL)
				{
					delete headNode;
					headNode = tempNext;
					headNode->setPrev(NULL);
				}
				//temp为表尾时
				else if(temp->getPrevPtr()!=NULL&&temp->getNextPtr()==NULL)
				{
					temp->getPrevPtr()->setNext(NULL);
					delete temp;
				}
				else{
					temp->getPrevPtr()->setNext(temp->getNextPtr());
					temp->getNextPtr()->setPrev(temp->getPrevPtr());
					delete temp;
				}
				listLength = listLength - 1;
			}
			break;
		}
		temp = tempNext;
	}
	if(length==listLength)//未在表中找到number
		cout << number << " is not in the list." << endl;
	else
		cout << "first finded elem " << number << " has been deleted from the list." << endl;
}

void LinkedList::search(int number)
{
	if(this->isEmpty)
		cout << "the list is empty,"<< number << " cann't be find in the list." << endl;
	else{
		LinkedList indexList = LinkedList();//创建一个链表对象用以存储可能出现的下标
		Node *temp = headNode;
		int count = 0;
		while(temp!=NULL)
		{
			count = count + 1;
			if(temp->getElem()==number)
			{
				indexList.addElemToTail(count);
			}
			temp = temp->getNextPtr();
		}
		if(indexList.getListLength()!=0)
		{
			cout << "the elem's index that elem equal with " << number << " is :" << endl;
			temp = indexList.headNode;
			while(temp!=NULL)
			{	
				cout << temp->getElem() << " ";
				temp = temp->getNextPtr();
			}
			cout << endl;
		}
	}
}

//向链表的第index处插入元素number，
void LinkedList::insertElem(int index,int number)
{
	if(listLength==0)
	{	
		if(index==1)//空表中插入元素
		{	
			headNode->setElem(number);
			this->isEmpty = false;
			this->listLength = 1;
		}
		else
			cout << "insert error." << endl;
		return;
	}
	if(index<=0||index>listLength)
	{
		cout << "index beyond the list size." << endl;
		return;
	}
	if(index==1)//index为1，就是向表头添加元素
	{
		this->addElemToHead(number);
		return;
	}
	if(index==listLength)//向原来表的表尾添加元素,变成倒数第二个了
	{
		Node *newNode = new Node;
		Node *tailNode = this->getPtr(listLength);//原来的表尾指针
		newNode->setElem(number);
		newNode->setPrev(tailNode->getPrevPtr());
		newNode->setNext(tailNode);
		tailNode->getPrevPtr()->setNext(newNode);
		tailNode->setPrev(newNode);
		listLength = listLength + 1;
		return;
	}
	//向一定长度的链表中添加，至少为3？
	Node *newNode = new Node;
	Node *tempNode;
	for(int i=1;i<=index;i++)
	{
		if(i==1)
			tempNode = headNode;
		else
			tempNode = tempNode->getNextPtr();
	}
	newNode->setElem(number);
	newNode->setNext(tempNode);
	newNode->setPrev(tempNode->getPrevPtr());
	tempNode->getPrevPtr()->setNext(newNode);
	tempNode->setPrev(newNode);
	listLength = listLength + 1;
}

#include <cstdlib>

class Node
{
private:
	int elem;
	Node *next;
	Node *prev;
public:
	Node();
	int getElem();
	void setNext(Node *);
	void setPrev(Node *);
	Node *getNextPtr();
	Node *getPrevPtr();
	void setElem(int);//改变节点中存放的值
};

Node::Node()
{
	this->next = this->prev = NULL;
}
int Node::getElem()
{
	return this->elem;
}
Node *Node::getNextPtr()
{
	return this->next;
}
Node *Node::getPrevPtr()
{
	return this->prev;
}
void Node::setNext(Node *n)
{
	this->next = n;
}
void Node::setPrev(Node *p)
{
	this->prev = p;
}
void Node::setElem(int k)
{
	elem = k;
}

//LinkedList.cpp
#include "LinkedList.h"
int main()
{
	LinkedList list = LinkedList();
	cout << "the initialize of list has finished." << endl;
	list.addElem();
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;
	
	cout << "clear the list." << endl;
	list.clearList();
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;

	list.addElem();
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;

	cout << "add 8 to the head of list." << endl;
	list.addElemToHead(8);
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;
	
	cout << "add 90  to the tail of list." << endl;
	list.addElemToTail(90);
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;

	cout << "search 8 from the list." << endl;
	list.search(8);

	cout << "delete the first elem that equal with 8." << endl;
	list.deleteElem3(8);
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;

	cout << "delete all the elem that equal with 8." << endl;
	list.deleteElem2(8);
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;

	cout << "insert 90 to the list that index is 3." << endl;
	list.insertElem(3,90);
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;

	cout << "delete the node's that index is 3" << endl;
	list.deleteElem1(3);
	list.printList();
	cout << "the length of list is :" << list.getListLength() << endl;

	system("pause >> cout");
	return 0;
}