数据结构(C++)之Double Linked List实践

//double linked list (type int),the position starts from 0
#include <iostream>
using namespace std;

//Class Node
class Node
{
public:
    Node();
    Node(int val);
    ~Node();

    void setVal(int val);
    int getVal();

    Node* prior;   //指向前节点指针
    Node* next;   //指向后节点指针

private:
    int val = 0;
};

Node::Node()
{
}

Node::Node(int val)
{
    this->val = val;
    prior = next = nullptr;
}

Node::~Node()
{
}

void Node::setVal(int val)
{
    this->val = val;
}

int Node::getVal()
{
    return this->val;
}

//Class DoubleLinkedList
class DLlist
{
public:

    DLlist(int size);
    ~DLlist();

    int getSize();

    void insert(int num, int pos);   //在两节点间插入，插入位置的前后节点必须都存在

    void deleteList(int pos);   //删除节点，删除位置的前后节点必须都存在

    void addFirst(int element);     //pushFront

    void addLast(int element);   //pushBack

    int removeFirst();

    int removeLast();

    int returnNth(int pos);

    bool isEmpty();

    void printList();


    void Clear();

private:
    int size = 0;
    Node* head;  //指向头节点的指针
    Node* tail;     //指向尾节点的指针

    Node* GetPointer(int pos);   //查找节点

};

DLlist::DLlist(int size)
{
    this->size = size;
    head = new Node;
    head->prior = nullptr;
    head->next = nullptr;
    tail = head;
    for (int i = 0; i < this->size; i++)
    {
        int v;
        cout << "Enter the value of No. " << i + 1 << " Node: ";
        cin >> v;
        if (i == 0)
        {
            head->setVal(v);
        }
        else
        {
            Node* temp = new Node;
            temp->setVal(v);
            temp->next = nullptr;
            temp->prior = tail;
            tail->next = temp;
            tail = temp;
        }
    }
}

DLlist::~DLlist()
{
    Clear();
}

int DLlist::getSize()
{
    return this->size;
}

void DLlist::insert(int num, int pos)
{
    Node* temp = new Node;
    Node* position;
    temp->setVal(num);
    position = GetPointer(pos);
    (position->prior)->next = temp;
    temp->next = position;
    temp->prior = position->prior;
    position->prior = temp;
    size++;
}

void DLlist::deleteList(int pos)
{
    Node* position;
    position = GetPointer(pos);
    (position->prior)->next = position->next;
    (position->next)->prior = position->prior;
    delete position;
    size--;
}

void DLlist::addFirst(int element)
{
    if (head == nullptr)
    {
        head->setVal(element);
        head->prior = nullptr;
        head->next = nullptr;
        tail = head;
        size++;
    }
    else
    {
        /*我们要在头结点前再插入一个结点，需要先创建一个新的结点，将头结点的值保存在新节点，然后让新节点的下
        个结点指向头结点的下一个结点，再让新节点的prior指向头结点，这样就将新节点与原来的链表融合了，然后我
        们将头结点的数据换成element即可*/

        Node* temp = new Node;
        temp->setVal(head->getVal());
        temp->next = head->next;
        temp->prior = head;
        if (size > 1)
        {
            (head->next)->prior = temp;
        }
        head->next = temp;
        head->setVal(element);
        size++;
    }
}

void DLlist::addLast(int element)
{
    if (head == nullptr)
    {
        head->setVal(element);
        head->prior = nullptr;
        head->next = nullptr;
        tail = head;
        size++;
    }
    else
    {
        Node* temp = new Node;
        temp->setVal(tail->getVal());
        temp->prior = tail->prior;
        temp->next = tail;
        if (size - 1 != 0)
        {
            (tail->prior)->next = temp;
        }
        tail->prior = temp;
        tail->setVal(element);
        size++;
    }
}

int DLlist::removeFirst()
{
    int v = head->getVal();

    head = head->next;
    if (size > 1)
    {
        head->prior = nullptr;
    }

    size--;
    return v;
}

int DLlist::removeLast()
{
    int v = tail->getVal();

    tail = tail->prior;
    if (size>1)
    {
        tail->next = nullptr;
    }

    size--;
    return v;
}

int DLlist::returnNth(int pos)
{
    return GetPointer(pos)->getVal();
}

bool DLlist::isEmpty()
{
    if (size == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void DLlist::printList()
{
    for (int i = 0; i < size; i++)
    {
        cout << "No. " << i + 1 << " = " << GetPointer(i)->getVal() << endl;
    }
}

void DLlist::Clear()
{
    while (head != nullptr)
    {
        Node * temp = head->next;
        delete head;
        head = temp;
    }
    tail = nullptr;
    size = 0;
}

Node* DLlist::GetPointer(int pos)
{
    Node* pNode = nullptr;
    if (pos<0 || pos>size - 1)
    {
        cout << "Out of range! " << endl;
        return nullptr;
    }
    else
    {
        pNode = head;
        for (int i = 0; i < pos; i++)
        {
            pNode = pNode->next;
        }
        return pNode;
    }
}

int main()
{
    DLlist d(3);
    cout << endl;
    cout << "Size: " << d.getSize() << endl;
    d.printList();
    cout << endl;

    cout << "Insert 10 at position 1" << endl;
    d.insert(10, 1);
    cout << "Size: " << d.getSize() << endl;
    d.printList();

    cout << endl;
    cout << "Addfirst 100" << endl;
    d.addFirst(100);
    cout << "Now No.1's value= " << d.returnNth(0) << endl;
    d.printList();

    cout << endl;
    cout << "Remove last" << endl;
    d.removeLast();
    d.printList();

    cout << endl;
    cout << "Remove first" << endl;
    d.removeFirst();
    d.printList();

    cout << endl;
    d.Clear();
    cout << "Use Clear()" << endl;
    cout << "isEmpty: " << boolalpha << d.isEmpty() << endl;

    system("pause");
    return 0;
}

---

取消int类型，加入模板

//double linked list ,the position starts from 0
#include <iostream>
#include <iomanip>
using namespace std;

//Class Node
template <typename T>
class Node
{
public:
    Node();
    Node(T val);
    ~Node();

    void setVal(T val);
    T getVal();

    Node* prior;   //指向前节点指针
    Node* next;   //指向后节点指针

private:
    T val ;
};

template<typename T>
Node<T>::Node()
{
    this->val = T();
}

template<typename T>
Node<T>::Node(T val)
{
    this->val = val;
    prior = next = nullptr;
}


template<typename T>
Node<T>::~Node()
{
}


template<typename T>
void Node<T>::setVal(T val)
{
    this->val = val;
}

template<typename T>
T Node<T>::getVal()
{
    return this->val;
}

//Class DoubleLinkedList
template<typename T>
class DLlist
{
public:

    DLlist(int size);
    ~DLlist();

    int getSize();

    void insert(T num, int pos);   //在两节点间插入，插入位置的前后节点必须都存在

    void deleteList(int pos);   //删除节点，删除位置的前后节点必须都存在

    void addFirst(T element);     //pushFront

    void addLast(T element);   //pushBack

    T removeFirst();

    T removeLast();

    T returnNth(int pos);

    bool isEmpty();

    void printList();


    void Clear();

private:
    int size = 0;
    Node<T>* head;  //指向头节点的指针
    Node<T>* tail;     //指向尾节点的指针

    Node<T>* GetPointer(int pos);   //查找节点

};

template<typename T>
DLlist<T>::DLlist(int size)
{
    this->size = size;
    head = new Node<T>;
    head->prior = nullptr;
    head->next = nullptr;
    tail = head;
    for (int i = 0; i < this->size; i++)
    {
        T v;
        cout << "Enter the value of No. " << i + 1 << " Node: ";
        cin >> v;
        if (i == 0)
        {
            head->setVal(v);
        }
        else
        {
            Node<T>* temp = new Node<T>;
            temp->setVal(v);
            temp->next = nullptr;
            temp->prior = tail;
            tail->next = temp;
            tail = temp;
        }
    }
}

template<typename T>
DLlist<T>::~DLlist()
{
    Clear();
}

template<typename T>
int DLlist<T>::getSize()
{
    return this->size;
}

template<typename T>
void DLlist<T>::insert(T num, int pos)
{
    Node<T>* temp = new Node<T>;
    Node<T>* position;
    temp->setVal(num);
    position = GetPointer(pos);
    (position->prior)->next = temp;
    temp->next = position;
    temp->prior = position->prior;
    position->prior = temp;
    size++;
}

template<typename T>
void DLlist<T>::deleteList(int pos)
{
    Node<T>* position;
    position = GetPointer(pos);
    (position->prior)->next = position->next;
    (position->next)->prior = position->prior;
    delete position;
    size--;
}

template<typename T>
void DLlist<T>::addFirst(T element)
{
    if (head == nullptr)
    {
        head->setVal(element);
        head->prior = nullptr;
        head->next = nullptr;
        tail = head;
        size++;
    }
    else
    {
        /*我们要在头结点前再插入一个结点，需要先创建一个新的结点，将头结点的值保存在新节点，然后让新节点的下
        个结点指向头结点的下一个结点，再让新节点的prior指向头结点，这样就将新节点与原来的链表融合了，然后我
        们将头结点的数据换成element即可*/

        Node<T>* temp = new Node<T>;
        temp->setVal(head->getVal());
        temp->next = head->next;
        temp->prior = head;
        if (size > 1)
        {
            (head->next)->prior = temp;
        }
        head->next = temp;
        head->setVal(element);
        size++;
    }
}

template<typename T>
void DLlist<T>::addLast(T element)
{
    if (head == nullptr)
    {
        head->setVal(element);
        head->prior = nullptr;
        head->next = nullptr;
        tail = head;
        size++;
    }
    else
    {
        Node<T>* temp = new Node<T>;
        temp->setVal(tail->getVal());
        temp->prior = tail->prior;
        temp->next = tail;
        if (size - 1 != 0)
        {
            (tail->prior)->next = temp;
        }
        tail->prior = temp;
        tail->setVal(element);
        size++;
    }
}

template<typename T>
T DLlist<T>::removeFirst()
{
    T v = head->getVal();

    head = head->next;
    if (size > 1)
    {
        head->prior = nullptr;
    }

    size--;
    return v;
}

template<typename T>
T DLlist<T>::removeLast()
{
    T v = tail->getVal();

    tail = tail->prior;
    if (size>1)
    {
        tail->next = nullptr;
    }

    size--;
    return v;
}

template<typename T>
T DLlist<T>::returnNth(int pos)
{
    return GetPointer(pos)->getVal();
}

template<typename T>
bool DLlist<T>::isEmpty()
{
    if (size == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template<typename T>
void DLlist<T>::printList()
{
    for (int i = 0; i < size; i++)
    {
        cout << "No. " << i + 1 << " = " <<setiosflags(ios::fixed)<<setprecision(2)<<GetPointer(i)->getVal() << endl;
    }
}

template<typename T>
void DLlist<T>::Clear()
{
    while (head != nullptr)
    {
        Node<T>* temp = head->next;
        delete head;
        head = temp;
    }
    tail = nullptr;
    size = 0;
}

template<typename T>
Node<T>* DLlist<T>::GetPointer(int pos)
{
    Node<T>* pNode = nullptr;
    if (pos<0 || pos>size - 1)
    {
        cout << "Out of range! " << endl;
        return nullptr;
    }
    else
    {
        pNode = head;
        for (int i = 0; i < pos; i++)
        {
            pNode = pNode->next;
        }
        return pNode;
    }
}

int main()
{
    DLlist<double> d(3);
    cout << endl;
    cout << "Size: " << d.getSize() << endl;
    d.printList();
    cout << endl;

    cout << "Insert 10.0 at position 1" << endl;
    d.insert(10.0, 1);
    cout << "Size: " << d.getSize() << endl;
    d.printList();

    cout << endl;
    cout << "Addfirst 100.0" << endl;
    d.addFirst(100.0);
    cout << "Now No.1's value= " << d.returnNth(0) << endl;
    d.printList();

    cout << endl;
    cout << "Remove last" << endl;
    d.removeLast();
    d.printList();

    cout << endl;
    cout << "Remove first" << endl;
    d.removeFirst();
    d.printList();

    cout << endl;
    d.Clear();
    cout << "Use Clear()" << endl;
    cout << "isEmpty: " << boolalpha << d.isEmpty() << endl;

    system("pause");
    return 0;
}