c++的双向链表操作

#include <iostream>

using namespace std;

class Node {

public:

    int element;

    Node *next;

    Node *previous;

    Node(int element, Node *next, Node *previous) {

        this->element = element;

        this->next = next;

        this->previous = previous;

    }

};

class LinkedList {

    LinkedList();

    void addFirst(int);

    void addLast(int);

    void add(int index, int element);

    int getFirst();

    int getLast();

    int get(int);

    int removeFirst();

    int removeLast();

    int remove(int);

    void iterate();

private:

    Node *header;

    int size;

};

/*

* 构造方法。

* 生成一个空的节点介于表头和表尾之间，初始前后指针都指向自己。

*/

LinkedList::LinkedList() {

    header = new Node(NULL, NULL, NULL);

    header->next = header;

    header->previous = header;

    size = 0;

}

/*

* 在链表头部添加一个元素。

* 生成一个新的节点，向前指向空节点，向后指向原来空节点的下一个节点，即原来的第一个节点。

* 空节点向后指向此节点，原来的第一个节点向前指向此节点。

*/

void LinkedList::addFirst(int i) {

    header->next = new Node(i, header->next, header);

    header->next->next->previous = header->next;

    ++size;

}

/*

* 在链表最后添加一个元素。

* 生成一个新的节点，向前指向原来空节点的前一个节点，即原来的最后一个节点，向后指向空节点。

* 原来的最后一个节点向后指向此节点，空节点向前指向此节点。

*/

void LinkedList::addLast(int i) {

    header->previous = new Node(i, header, header->previous);

    header->previous->previous->next = header->previous;

    ++size;

}

/*

* 在指定的索引前插入一个元素。0 <= 索引 <= 链表长度。

* 如果索引值小于链表长度的一半，向后（正向）迭代获取索引值位置的节点，反之则向前（反向）。

* 生成一个新的节点，向前指向原来这个位置的节点的前一个节点，向后指向原来这个位置的节点。

* 原来这个位置的节点的前一个节点向后指向此节点，原来这个位置的节点向前指向此节点。

* （在指定的索引删除一个元素实现方法类似）

*/

void LinkedList::add(int index, int i) {

    if(index > size || index < 0) {

        cout << "Exception in add(): Index out of bound." << '\n';

    return;

    }

    Node *entry;

    if(index < size / 2) {

        entry = header->next;

        for(int i = 0; i < index; ++i)

            entry = entry->next;

    }

    else {

        entry = header;

        for(int i = size; i > index; --i)

            entry = entry->previous;

    }

    entry->previous->next = new Node(i, entry, entry->previous);

    entry->previous = entry->previous->next;

    ++size;

}

/*

* 获取链表第一个元素。

* 空节点向后指向的节点即是第一个元素。

*/

int LinkedList::getFirst() {

    if(!size)

        cout << "Exception in getFirst(): List is empty." << '\n';

    return header->next->element;

}

/*

* 获取链表最后一个元素。

* 空节点向前指向的节点即是最后一个元素。

*/

int LinkedList::getLast() {

    if(!size)

        cout << "Exception in getLast(): List is empty." << '\n';

    return header->previous->element;

}

/*

* 删除并返回链表第一个元素。

* 链表第二个节点向前指向空节点，空节点向后指向第二个节点。

*/

int LinkedList::removeFirst() {

    int remove = header->next->element;

    header->next->next->previous = header;

    header->next = header->next->next;

    --size;

    return remove;

}

/*

* 删除并返回链表最后一个元素。

* 链表倒数第二个节点向后指向空节点，空节点向前指向倒数第二个节点。

*/

int LinkedList::removeLast() {

    int remove = header->previous->element;

    header->previous->previous->next = header;

    header->previous = header->previous->previous;

    --size;

    return remove;

}

/*

* 用来输出所有元素的迭代方法。

*/

void LinkedList::iterate() {

    if(!size) {

        cout << "Exception in iterate(): List is empty." << '\n';

        return;

    }

    for(Node *entry = header->next; entry != header; entry = entry->next)

        cout << entry->element << " ";

    cout << '\n';

}

int main()

{

    cout << "Hello World!" << endl;

    return 0;

}