泛型双向链表
双向链表（doublyLinkedList.h）
/*************************************************************************
> File Name : doublyLinkedList.h
> Author : Harold
> Mail : 2106562095@qq.com
> Github : www.github.com/Haroldcc
> Created Time : 2020年02月28日 10时23分06秒
************************************************************************/
/***** 双向链表 *****/
#ifndef DOUBLYLINKEDLIST_H
#define DOUBLYLINKEDLIST_H
#include "linearList.h" // ADT
#include "myExceptions.h" // 异常类
#include <sstream> // for ostringstream
/*** 链表节点类 ***/
template <typename T>
class Node
{
public:
T element;
Node<T> *prev;
Node<T> *next;
Node(){};
Node(const T &element) { this->element = element; }
Node(const T &element, Node<T> *prev, Node<T> *next)
{
this->element = element;
this->prev = prev;
this->next = next;
}
};
/*** 双向链表类 ***/
template <typename T>
class doublyLinkedList : public linearList<T>
{
private:
void checkIndex(int index) const; // 索引异常检测
Node<T> *firstNode; // 链表头节点指针
Node<T> *lastNode; // 链表尾节点指针
int listSize; // 链表的元素个数
public:
/* 构造函数 */
doublyLinkedList(int initialCapacity = 10);
~doublyLinkedList();
/* ADT */
bool isEmpty() const { return this->listSize == 0; }
int size() const { return this->listSize; }
T &getElement(int index) const;
void setElement(int index, const T &element);
int indexOf(const T &element) const;
void removeByIndex(int index);
void removeByElement(const T &element);
void add(const T &element);
void add(int index, const T &element);
void clear();
void output(std::ostream &out) const;
};
// 默认构造
template <typename T>
doublyLinkedList<T>::doublyLinkedList(int initialCapacity)
{
if (initialCapacity < 1)
{
std::ostringstream s;
s << "初始化容量 = " << initialCapacity << "必须 > 0";
throw illegalParameterValue(s.str());
}
this->firstNode = nullptr;
this->lastNode = nullptr;
this->listSize = 0;
}
// 析构函数
template <typename T>
doublyLinkedList<T>::~doublyLinkedList()
{
}
template <typename T>
void doublyLinkedList<T>::checkIndex(int index) const
{
if (index < 0 || index >= this->listSize)
{
std::ostringstream s;
s << "index = " << index << "size = " << this->listSize;
throw illegalIndex(s.str());
}
}
// 根据索引获取对应的节点，如未找到，抛异常
template <typename T>
T &doublyLinkedList<T>::getElement(int index) const
{
checkIndex(index);
Node<T> *currentNode = this->firstNode;
for (int i = 0; i < index; i++)
currentNode = currentNode->next;
return currentNode->element;
}
// 根据索引设置元素值
template <typename T>
void doublyLinkedList<T>::setElement(int index, const T &element)
{
checkIndex(index);
Node<T> *currentNode = this->firstNode;
for (int i = 0; i < index; i++)
currentNode = currentNode->next;
currentNode->element = element;
}
// 返回给定元素的索引值，若未找到返回 -1
template <typename T>
int doublyLinkedList<T>::indexOf(const T &element) const
{
Node<T> *currentNode = this->firstNode;
int index = 0;
while (currentNode != nullptr && currentNode->element != element)
{
currentNode = currentNode->next;
index++;
}
if (currentNode == nullptr)
{
return -1;
}
else
{
return index;
}
}
// 删除指定索引处的元素值，未找到元素抛异常
template <typename T>
void doublyLinkedList<T>::removeByIndex(int index)
{
checkIndex(index);
Node<T> *deleteNode;
if (index == 0)
{ // 删除链表中的第一个元素
deleteNode = this->firstNode;
this->firstNode = this->firstNode->next;
}
else
{
Node<T> *p = this->firstNode;
for (int i = 0; i < index - 1; i++)
p = p->next;
deleteNode = p->next;
p->next = p->next->next;
}
this->listSize--;
delete deleteNode;
}
template <typename T>
void doublyLinkedList<T>::removeByElement(const T &element)
{
removeByIndex(indexOf(element));
}
template <typename T>
void doublyLinkedList<T>::add(const T &element)
{
add(this->listSize, element);
}
// 在指定索引处添加元素
template <typename T>
void doublyLinkedList<T>::add(int index, const T &element)
{
if (index < 0 || index > this->listSize)
{
std::ostringstream s;
s << "index = " << index << "size = " << this->listSize;
throw illegalIndex(s.str());
}
if (index == 0)
{ // 头部插入元素
this->firstNode = new Node<T>(element, nullptr, this->firstNode);
}
else
{
Node<T> *p = this->firstNode;
for (int i = 0; i < index - 1; i++)
{
p = p->next;
}
p->next = new Node<T>(element, p->prev, p->next);
}
this->listSize++;
}
template <typename T>
void doublyLinkedList<T>::clear()
{
while (this->firstNode != nullptr)
{
Node<T> *nextNode = this->firstNode->next;
delete this->firstNode;
this->firstNode = nextNode;
}
this->firstNode = this->lastNode = nullptr;
this->listSize = 0;
}
template <typename T>
void doublyLinkedList<T>::output(std::ostream &out) const
{
for (Node<T> *currentNode = this->firstNode;
currentNode != nullptr;
currentNode = currentNode = currentNode->next)
out << currentNode->element << " ";
}
// 重载 << 运算符
template <typename T>
std::ostream &operator<<(std::ostream &out, const doublyLinkedList<T> &list)
{
list.output(out);
return out;
}
#endif
测试（testDoublyLinkedList.cpp）
/*************************************************************************
> File Name : testDoublyLinkedList.cpp
> Author : Harold
> Mail : 2106562095@qq.com
> Github : www.github.com/Haroldcc
> Created Time : 2020年02月28日 20时38分11秒
************************************************************************/
#include <iostream>
#include "linearList.h"
#include "doublyLinkedList.h"
using namespace std;
int main()
{
doublyLinkedList<int> list;
list.add(1);
list.add(2);
cout << list << endl;
// test constructor
linearList<double> *x = new doublyLinkedList<double>;
doublyLinkedList<int> y, z;
// test size
cout << "Initial size of x, y, and z = "
<< x->size() << ", "
<< y.size() << ", "
<< z.size() << endl;
// test isEmpty
if (x->isEmpty())
cout << "x is isEmpty" << endl;
else
cout << "x is not isEmpty" << endl;
if (y.isEmpty())
cout << "y is isEmpty" << endl;
else
cout << "y is not isEmpty" << endl;
// test add
y.add(0, 2);
y.add(1, 6);
y.add(0, 1);
y.add(2, 4);
y.add(3, 5);
y.add(2, 3);
cout << "Inserted 6 integers, list y should be 1 2 3 4 5 6" << endl;
cout << "Size of y = " << y.size() << endl;
if (y.isEmpty())
cout << "y is isEmpty" << endl;
else
cout << "y is not isEmpty" << endl;
y.output(cout);
cout << endl
<< "Testing overloaded <<" << endl;
cout << y << endl;
// test indexOf
int index = y.indexOf(4);
if (index < 0)
cout << "4 not found" << endl;
else
cout << "The index of 4 is " << index << endl;
index = y.indexOf(7);
if (index < 0)
cout << "7 not found" << endl;
else
cout << "The index of 7 is " << index << endl;
// test getElement
cout << "Element with index 0 is " << y.getElement(0) << endl;
cout << "Element with index 3 is " << y.getElement(3) << endl;
// test removeByIndex
y.removeByIndex(1);
cout << "Element 1 erased" << endl;
cout << "The list is " << y << endl;
y.removeByIndex(2);
cout << "Element 2 erased" << endl;
cout << "The list is " << y << endl;
y.removeByIndex(0);
cout << "Element 0 erased" << endl;
cout << "The list is " << y << endl;
cout << "Size of y = " << y.size() << endl;
if (y.isEmpty())
cout << "y is isEmpty" << endl;
else
cout << "y is not isEmpty" << endl;
try
{
y.add(-3, 0);
}
catch (illegalIndex e)
{
cout << "Illegal index exception" << endl;
cout << "Insert index must be between 0 and list size" << endl;
e.outputMessage();
}
// a few more inserts, just for fun
y.add(0, 4);
y.add(0, 5);
y.add(0, 6);
y.add(0, 7);
cout << "y is " << y << endl;
y.clear();
return 0;
}
输出
1 2
Initial size of x, y, and z = 0, 0, 0
x is isEmpty
y is isEmpty
Inserted 6 integers, list y should be 1 2 3 4 5 6
Size of y = 6
y is not isEmpty
1 2 3 4 5 6
Testing overloaded <<
1 2 3 4 5 6
The index of 4 is 3
7 not found
Element with index 0 is 1
Element with index 3 is 4
Element 1 erased
The list is 1 3 4 5 6
Element 2 erased
The list is 1 3 5 6
Element 0 erased
The list is 3 5 6
Size of y = 3
y is not isEmpty
Illegal index exception
Insert index must be between 0 and list size
index = -3size = 3
y is 7 6 5 4 3 5 6
