双向链表

// main.cpp

#include "DoublyLinkedList.cpp"
#include <iostream>
using namespace std;

int main()
{
    int r[5] = {1, 2, 3, 4, 5};
    DoublyLinkedList<int> L(r, 5);

    cout << "链表长度：" << L.Length() << endl;

    cout << "执行插入操作前数据为：" << endl;
    L.PrintList(); //显示链表中所有元素
    try
    {
        L.Insert(2, 3); //在第2个位置插入值为3的元素
    }
    catch (const char *s)
    {
        cout << s << endl;
    }
    cout << "执行插入操作后数据为：" << endl;
    L.PrintList(); //显示双向链表的所有元素

    cout << "值为5的元素位置为：";
    cout << L.Locate(5) << endl; //查找元素5,并返回在双向链表中位置

    cout << "执行删除操作前数据为：" << endl;
    L.PrintList(); //显示双向链表的所有元素
    try
    {
        L.Delete(1); //删除第1个元素
    }
    catch (const char *s)
    {
        cout << s << endl;
    }
    cout << "执行删除操作后数据为：" << endl;
    L.PrintList(); //显示双向链表的所有元素

    return 0;
}

// DoublyLinkedList.h

#ifndef _DOUBLYLINKEDLIST_H
#define _DOUBLYLINKEDLIST_H 1

template <class DataType>
struct Node // 链表的节点
{
    DataType data;
    Node<DataType> *prev, *next;
};

// 双向链表：带头节点
// 以下是类DoublyLinkedList的声明
template <class DataType>
class DoublyLinkedList
{
public:
    DoublyLinkedList();                    // 建立只有头结点的空链表
    DoublyLinkedList(DataType a[], int n); // 建立有n个元素的双向链表
    ~DoublyLinkedList();                   // 析构函数
    int Locate(DataType x);                // 在双向链表中查找值为x的元素序号
    void Insert(int i, DataType x);        // 在第i个位置插入元素值为x的结
    DataType Delete(int i);                // 在双向链表中删除第i个结点
    void PrintList();                      // 按序号依次输出各元素
    int Length();                          // 返回链表长度
private:
    Node<DataType> *first, *last; // 双向链表的头指针和尾指针
    int length;                   // 双向链表的长度
};

#endif /* _DOUBLYLINKEDLIST_H */

// DoublyLinkedList.cpp

#include "DoublyLinkedList.h"
#include <iostream>
using namespace std;

template <typename DataType>
DoublyLinkedList<DataType>::DoublyLinkedList() // 建立只有头结点的空链表
{
    first = new Node<DataType>, last = new Node<DataType>;
    first->prev = last->next = NULL;
    first->next = last;
    last->prev = first;
    length = 0;
}

template <typename DataType>
DoublyLinkedList<DataType>::DoublyLinkedList(DataType a[], int n) // 建立有n个元素的双向链表
{
    first = new Node<DataType>, last = new Node<DataType>;
    first->prev = last->next = NULL;
    first->next = last;
    last->prev = first;
    Node<DataType> *p = first, *s;
    for (int i = 0; i < n; i++)
        s = new Node<DataType>{a[i], p, NULL}, p->next = s, p = s;
    p->next = last;
    last->prev = p;
    length = n;
}

template <typename DataType>
DoublyLinkedList<DataType>::~DoublyLinkedList() // 析构函数
{
    for (Node<DataType> *p = first->next; p; p = p->next)
        delete p->prev;
    delete last;
}

template <typename DataType>
int DoublyLinkedList<DataType>::Locate(DataType x) // 在双向链表中查找值为x的元素序号
{
    int cnt = 1;
    for (Node<DataType> *p = first->next; p != last; p = p->next, cnt++)
        if (p->data == x)
            return cnt;
    return 0;
}

template <typename DataType>
void DoublyLinkedList<DataType>::Insert(int i, DataType x) // 在第i个位置插入元素值为x的结
{
    if (i <= 0 || i > length)
        throw "位置";
    Node<DataType> *p = first->next, *pre = first;
    i--;
    for (int j = 0; j < i; j++)
        pre = p, p = p->next;
    Node<DataType> *s = new Node<DataType>{x, pre, p};
    pre->next = p->prev = s;
    length++;
}

template <typename DataType>
DataType DoublyLinkedList<DataType>::Delete(int i) // 在双向链表中删除第i个结点
{
    if (i <= 0 || i > length)
        throw "位置";
    i--;
    Node<DataType> *p = first->next, *pre = first;
    for (int j = 0; j < i; j++)
        pre = p, p = p->next;
    DataType ans = p->data;
    pre->next = p->next;
    p->next->prev = pre;
    delete p;
    length--;
    return ans;
}

template <typename DataType>
void DoublyLinkedList<DataType>::PrintList() // 按序号依次输出各元素
{
    for (Node<DataType> *p = first->next; p != last; p = p->next)
        cout << p->data << " ";
    cout << endl;
}

template <typename DataType>
int DoublyLinkedList<DataType>::Length() { return length; }