# 数据结构基础(12) --双向循环链表的设计与实现

(1) “查询” 和单链表相同;

(2)“插入” 和“删除”时需要同时修改两个方向上的指针。

但是对于双向循环链表则在表尾插入非常的迅速, 只需O(1)的时间,因为有指向前面的指针, 因此双向循环链表会很容易的找到位于表尾的元素,因此双向循环链表比较适用于频繁在表尾插入的情况.

class DoubleListNode
{
private:
Type data;
DoubleListNode *prev;   //前向指针域
DoubleListNode *next;   //后项指针域
};

template <typename Type>
class DoubleListNode
{
//友元声明
friend class DoubleList<Type>;
friend class ListIterator<Type>;

template <typename T>
friend ostream &operator<<(ostream &os, const DoubleList<T> &list);
private:
DoubleListNode(const Type &dataValue)
:data(dataValue),prev(NULL),next(NULL) {}

Type data;
DoubleListNode *prev;   //前向指针域
DoubleListNode *next;   //后项指针域
};

template <typename Type>
class DoubleList
{
friend class ListIterator<Type>;
template <typename T>
friend ostream &operator<<(ostream &os, const DoubleList<T> &list);
public:
DoubleList();
~DoubleList();

void push_back(const Type &data);
void push_front(const Type &data);
void insert(int position, const Type &data);

void pop_front();
void pop_back();
void remove(const Type &removeData);

bool search(const Type &searchData) const;
bool isEmpty() const
{
return (first->next == first);
}

private:
//将节点x插入到节点previous后面
void insertPrivate(DoubleListNode<Type> *previous,
DoubleListNode<Type> *x);
void removePrivate(DoubleListNode<Type> *x);

private:
DoubleListNode<Type> *first;
};

//构造链表
template <typename Type>
DoubleList<Type>::DoubleList()
{
first = new DoubleListNode<Type>(0);
first->next = first;
first->prev = first;
}
//析构链表
template <typename Type>
DoubleList<Type>::~DoubleList()
{
DoubleListNode<Type> *deleteNode = NULL;
//保存链表尾元素
DoubleListNode<Type> *tmp = first;

//first首先指向第一个真实的元素
first = first->next;
//一路到达链表结尾
while (first != tmp)
{
deleteNode = first;
first = first -> next;
delete deleteNode;
}
// 释放掉链表的空节点(表头)
delete tmp;
}

//同为private成员
//插入节点
template <typename Type>
void DoubleList<Type>::insertPrivate(DoubleListNode<Type> *previous,
DoubleListNode<Type> *x)
{
x->prev = previous;
x->next = previous->next;
previous->next->prev = x;
previous->next = x;
}

//删除节点
template <typename Type>
void DoubleList<Type>::removePrivate(DoubleListNode<Type> *x)

{
if (x == first)
throw std::range_error("permission denied to delete first pointer");

x->prev->next = x->next;
x->next->prev = x->prev;
delete x;
}

//插入到表尾
template <typename Type>
void DoubleList<Type>::push_back(const Type &data)
{
DoubleListNode<Type> *newNode = new DoubleListNode<Type>(data);
//找到first的前一个节点
DoubleListNode<Type> *previous = first->prev;

//插入
insertPrivate(previous, newNode);
}
//插入到表头
template <typename Type>
void DoubleList<Type>::push_front(const Type &data)
{
DoubleListNode<Type> *newNode = new DoubleListNode<Type>(data);
//插入到first之后
insertPrivate(first, newNode);
}

//插入到任意位置(依position指定)
template <typename Type>
void DoubleList<Type>::insert(int position, const Type &data)
{
if (position == 1)
return push_front(data);

int count = 1;
//previous 代表着要插入位置之前的一个位置
DoubleListNode<Type> *previous = first->next;

//如果position过大, 则previous查找到first就会停止
//此时应该将该元素插入到链表结尾
while (count < position-1 && previous != first)
{
++ count;
previous = previous->next;
}

//如果查找到了链表结尾或此时链表为空, 因此插入到表尾
if (previous == first)
return push_back(data);

//如果找到了合适的插入位置
DoubleListNode<Type> *newNode = new DoubleListNode<Type>(data);
insertPrivate(previous, newNode);
}

//删除表尾元素
template <typename Type>
void DoubleList<Type>::pop_back()
{
removePrivate(first->prev);
}
//删除表头元素
template <typename Type>
void DoubleList<Type>::pop_front()
{
removePrivate(first->next);
}

//删除元素值为removeData的所有元素
template <typename Type>
void DoubleList<Type>::remove(const Type &removeData)
{
if (isEmpty())

for( DoubleListNode<Type> *searchNode = first->next;
searchNode != first;
searchNode = searchNode->next)
{
if (searchNode->data == removeData)
removePrivate(searchNode);
}
}

template <typename Type>
bool DoubleList<Type>::search(const Type &searchData) const
{
DoubleListNode<Type> *searchNode = first->next;
while (searchNode != first)
{
if (searchNode->data == searchData)
return true;

searchNode = searchNode->next;
}
return false;
}

template <typename Type>
ostream &operator<<(ostream &os, const DoubleList<Type> &list)
{
for (DoubleListNode<Type> *currentNode = (list.first)->next;
currentNode != list.first;
currentNode = currentNode->next)
os << currentNode->data << ' ';

return os;
}

## 双向循环链表迭代器的设计与实现:

//除了添加了operator--, 几乎没做任何改变
template <typename Type>
class ListIterator
{
public:
ListIterator(const DoubleList<Type> &_list):
list(_list),
currentNode((_list.first)->next) {}

//重载 *operator
const Type &operator*() const throw (std::out_of_range);
Type &operator*() throw (std::out_of_range);

//重载 ->operator
const DoubleListNode<Type> *operator->() const throw (std::out_of_range);
DoubleListNode<Type> *operator->() throw (std::out_of_range);

//重载 ++operator
ListIterator &operator++() throw (std::out_of_range);
//注意:此处返回的是值,而不是reference
ListIterator operator++(int) throw (std::out_of_range);

//重载 --operator,
// 其实这个版本的--operator是不完美的,
// 因为他没有做任何的判错控制
ListIterator &operator--();
//注意:此处返回的是值,而不是reference
ListIterator operator--(int);

bool isEmpty() const
{
return (currentNode == list.first);
}

private:
const DoubleList<Type> &list;
DoubleListNode<Type> *currentNode;
};
template <typename Type>
const Type &ListIterator<Type>::operator*() const
throw (std::out_of_range)
{
if (isEmpty())
throw std::out_of_range("iterator is out of range");
// 返回当前指针指向的内容
return currentNode->data;
}
template <typename Type>
Type &ListIterator<Type>::operator*()
throw (std::out_of_range)
{
return
const_cast<Type &>(
static_cast<const ListIterator<Type> &>(*this).operator*()
);
}
template <typename Type>
const DoubleListNode<Type> *ListIterator<Type>::operator->() const
throw (std::out_of_range)
{
if (isEmpty())
throw std::out_of_range("iterator is out of range");

//直接返回指针
return currentNode;
}

template <typename Type>
DoubleListNode<Type> *ListIterator<Type>::operator->()
throw (std::out_of_range)
{
return
const_cast<DoubleListNode<Type> *> (
static_cast<const ListIterator<Type> >(*this).operator->()
);
}
template <typename Type>
ListIterator<Type> &ListIterator<Type>::operator++()
throw (std::out_of_range)
{
if (isEmpty())
throw std::out_of_range("iterator is out of range");
//指针前移
currentNode = currentNode->next;
return *this;
}
template <typename Type>
ListIterator<Type> ListIterator<Type>::operator++(int)
throw (std::out_of_range)
{
ListIterator tmp(*this);
++ (*this); //调用前向++版本

return tmp;
}
template <typename Type>
ListIterator<Type> &ListIterator<Type>::operator--()
{
//指针前移
currentNode = currentNode->prev;
return *this;
}
template <typename Type>
ListIterator<Type> ListIterator<Type>::operator--(int)
{
ListIterator<Type> tmp(*this);
-- (*this);

return tmp;
}

int main()
{
cout << "-------- 1 --------" << endl;
DoubleList<int> myList;

for (int i = 0; i < 3; ++i)
myList.push_back(i+1);
for (int i = 0; i < 5; ++i)
myList.push_front(10+i);
for (int i = 0; i < 3; ++i)
myList.push_back(i+1);

ListIterator<int> iter(myList), iter2(myList);
while (!iter.isEmpty())
{
cout << *iter << ' ';
++ iter;

++ iter2;
}
cout << endl;

-- iter2;
while (!iter2.isEmpty())
{
cout << *iter2 << ' ';
iter2 --;
}
cout << endl;

cout << "-------- 2 --------" << endl;

cout << myList << endl;
cout << "Test insert..." << endl;
myList.insert(1, 14);
myList.insert(2, 13);
myList.insert(2, 13);
myList.insert(88, 88);
cout << myList << endl;

myList.pop_back();
myList.pop_front();
cout << myList << endl;

for (int i = 0; i < 5; ++i)
{
if (myList.search(i))
cout << i << ": Have found!" << endl;
else
cout << i << ": Not in the list!" << endl;
}

cout << "Test remove..." << endl;
cout << myList << endl;
int value;
while (cin >> value)
{
try
{
myList.remove(value);
}
catch (const std::exception &e)
{
cerr << e.what() << endl;
}

cout << myList << endl;
if (myList.isEmpty())
{
cout << "empty" << endl;
}
else
{
cout << "not empty" << endl;
}
}

return 0;
}