双向链表C++实现

DoubleLinkList.h

#pragma once
#ifndef DOUBLELINKLIST_H
#define DOUBLELINKLIST_H
//双向链表，下面英文名字写错了
#include<iostream>
using std::cout;
using std::endl;
using std::cin;
typedef int ElemType;

class Node
{
public:
	Node(Node* left=nullptr,Node* right=nullptr):prior(left),next(right){}
	Node* prior;
	Node* next;
	ElemType data;
};


class doubleLinkList
{
public:
	doubleLinkList();
	~doubleLinkList();
	bool empty();//查看是否为空表
	void getElem(int nPos, ElemType& elem);//获得第nPos位置的元素值，并返回给elem
	bool findElem(ElemType elem);//查找列表中是否有elem值d的元素
	void insert(ElemType elem);//默认在列表尾部插入elem元素
	void insert(int nPos, ElemType elem);//在第nPos位置后插入值为elem的元素
	void remove(int nPos, ElemType& elem);//删除第nPos位置的元素，并将其值返回给elem元素
	void remove();//默认删除尾部的元素
	int length();//返回列表长度
	void print();//打印列表
private:
	Node* head;
};
#endif // !DOUBLELINKLIST_H

DoubleLinkList.cpp

#include"DoubleLinkList.h"

//构造函数,建立一个空表，双向链表的空表定义是前驱和后驱都指向头指针
doubleLinkList::doubleLinkList(){
	head = new Node;//为head分配内存
	if (head == nullptr) {
		cout << "分配内存失败" << endl;
		return;
	}
	head->next = head;
	head->prior = head;
}

//析构函数
doubleLinkList::~doubleLinkList(){
	if (!empty())
	{
		Node* p = head->next;
		Node* q = nullptr;
		while (p!=head)
		{
			q = p;
			p = p->next;
			delete q;
		}
	}
	delete head;
}

//查看是否为空表
bool doubleLinkList::empty(){
	if (head->next==head && head->prior==head)
		return true;
	return false;
}

//返回列表长度
int doubleLinkList::length() {
	int Index = 0;
	if (!empty())
	{		
		Node* p = head->next;
		while (p!=head)
		{
			++Index;
			p = p->next;
		}
		return Index;
	}
	return Index;
}

//获得第nPos位置的元素值，并返回给elem
void doubleLinkList::getElem(int nPos, ElemType& elem){
	if (nPos < 0) {
		cout << "输入位置不得小于0，请重新输入位置" << endl;
		return;
	}
	else if(empty()){
		cout << "列表为空" << endl;
		return;
	}
	Node* p = head->next;
	int Index = 0;
	while (p!=head && Index<nPos)
	{
		p = p->next;
		++Index;
	}
	if (p == head)
	{
		if (Index == nPos) {//如果恰好两个条件都满足，即在末尾的元素恰好是npos
			elem = p->prior->data;
			return;
		}
		cout << "输入位置过大,请重新输入" << endl;
		return;
	}
	elem = p->prior->data;//nPos位置的元素在当前p的上一个节点
}

//查找列表中是否有elem值的元素
bool doubleLinkList::findElem(ElemType elem) {
	if (!empty())
	{
		Node* p = head->next;
		while (p!=head)
		{
			if (p->data == elem)
				return true;
			p = p->next;
		}
	}
	return false;
}

//默认在列表尾部插入elem元素
void doubleLinkList::insert(ElemType elem) {
	Node* q = (Node*)new Node[1];
	q->data = elem;
	if (empty()){
		Node* p = head;
		p->next = q;//先排后继，按箭头顺序赋值
		q->next = head;
		head->prior = q;//再排后继，按箭头顺序赋值
		q->prior = head;
	}
	else {
		Node* p = head->prior;				
		head->prior = q;//先排前继，按箭头顺序赋值
		q->prior = p;
		p->next = q;//先排后继，按箭头顺序赋值
		q->next = head;
	}
}

//在第nPos位置后插入值为elem的元素
void doubleLinkList::insert(int nPos, ElemType elem) {
	if (nPos < 0) {
		cout << "输入位置不得小于0，请重新输入位置" << endl;
		return;
	}
	int L = length();
	int Index = 1;
	Node* q = (Node*)new Node[1];
	if (nPos <= L)
	{
		Node* p = head->next;
		q->data = elem;
		while (p != head && Index < nPos) {//大于等于两个元素时会有移动
			++Index;
			p = p->next;
		}
		if (L = 0) {//空表插入
			head->next = q;//先排后继，按箭头顺序赋值
			q->next = head;
			head->prior = q;//再排后继，按箭头顺序赋值
			q->prior = head;
		}
		else if (Index == nPos && p->next == head) {//说明要在尾部结点插入元素，在不为空表时
			Node* s = head->prior;
			head->prior = q;//先排前继，按箭头顺序赋值
			q->prior = s;
			s->next = q;//先排后继，按箭头顺序赋值
			q->next = head;
		}
		else if (nPos == 0) {//在0位置后插入元素,头部插入
			head->next = q;//先排后继
			q->next = p;
			p->prior = q;
			q->prior = head;
		}
		else //非尾部,非头部插入
		{
			q->next = p->next;//逆序
			p->next = q;
			q->prior = p;
			q->next->prior = q;
		}
	}
	else
		cout << "输入位置过大，请重新输入位置" << endl;
}

//删除第nPos位置的元素，并将其值返回给elem元素
void doubleLinkList::remove(int nPos, ElemType& elem) {
	if (!empty() && nPos > 0) {
		int Index = 1;
		int L = length();
		if (nPos <= L)
		{
			Node* p = head->next;
			while (p != head && Index < nPos) {//两个元素时
				++Index;
				p = p->next;
			}
			elem = p->data;//赋值
			if (L>1)//一般情况，即大于一个元素时
			{
				p->prior->next = p->next;
				p->next->prior = p->prior;
			}
			else //仅有一个元素时
			{
				head->next = head;
				head->prior = head;
			}
			delete p;
			return;
		}
	}
	cout << "列表为空!" << endl;
	return;
}

//默认删除尾部的元素
void doubleLinkList::remove() {
	if (!empty()) {
		if (head->next->next!=head)//大于一个元素时
		{
			Node* p = head->prior;
			Node* q = head->prior->prior;
			head->prior = q;
			q->next = head;
			delete p;			
		}
		else {//一个元素时
			Node* p = head->prior;
			head->next = head;
			head->prior = head;
			delete p;
		}
		return;
	}
	cout << "列表为空! 或者 输入位置不得小于等于0" << endl;
	return;
}

//打印列表
void doubleLinkList::print() {
	cout << "列表元素是： ";
	if (!empty())
	{
		Node* p = head;
		while (p->next != head)
		{
			p = p->next;
			cout << p->data << " ";	
		}
		cout << endl;
	}
	else
	{
		cout << "The list is empty!" << endl;
		return;
	}
}

main.cpp

#include"DoubleLinkList.h"


int main() 
{
	doubleLinkList list;
	ElemType elem = 0;
	cout << "列表是否为空：" << list.empty() << endl;
	for (int i = 0; i < 10; i++)
		list.insert(i);
	list.print();
	for (int i = 0; i < 10; i++) {
		list.remove();
		if(i==9)//查看仅剩一个元素时的删除结果
			list.print();
	}
	cout << "分割线" << endl << endl;
	list.insert(0,1);//空表插入
	list.insert(1,2);//一个元素时插入
	list.print();
	list.insert(2, 3);//两个个元素时插入末尾
	list.print();
	list.insert(1, 4);//大于两个元素时插入中间
	list.print();
	cout << "分割线" << endl << endl;
	list.remove(3, elem);
	cout << "取得的元素是：" << elem << endl;
	list.print();

	return 1;
}