链表原理详解及其实现

什么是链表？

链表，顾名思义，是一条相互链接的数据节点表。每个节点由两部分组成：数据和指向下一个节点的指针。链表的基本结构如下图所示：

一般来说，链表的头结点不存放具体的数据，所以也被称为哑节点（dummy node）。原因在于这样可以比较好地区分链表的头结点，而且可以大大简化链表的各种操作，避免很多不必要的边界讨论。

链表的种类

单向链表 双向链表 循环链表 多向表（网状表）

链表的优缺点

这里的优缺点主要是和链表对应的另一个数据结构：数组相比得出的。
链表的优点在于：
1.物理存储单元上非连续，而且采用动态内存分配，能够有效的分配和利用内存资源；
2.节点删除和插入简单，不需要内存空间的重组。
作为一种数据结构，链表必然也有让人诟病的地方。链表的缺点在于：
1.不能进行索引访问，只能从头结点开始顺序查找；
2.数据结构较为复杂，需要大量的指针操作，容易出错。

单向链表的模板类实现

笔者实现了一个单向链表模板类，支持了绝大部分链表操作。
（笔者坚信好的代码不必写过多的注释，代码本身即具有良好的可阅读性）
首先需要定义链表节点类：

template <class T>
class Node
{
public:
    Node();
    ~Node();

    T val;
    Node *next;
};

链表类的定义如下：

template <class T>
class List
{
public:
    List();
    ~List();

    void isEmpty();
    void isHead(Node<T> *node);
    void isTail(Node<T> *node);

    Node<T> *getHead();
    Node<T> *getTail();

    Node<T> *find(T val);
    Node<T> *findPrevious(T val);

    void insert(Node<T> *node, T val);
    void append(T val);
    void remove(T val);
    void reverse();

    int size();
    void clear();
    void print();

private:
    Node<T> *_head;
};

下面是具体的链表操作实现：
1.链表是否为空

template <class T>
void List<T>::isEmpty()
{
    return _head->next == NULL;
}

2.判断节点是否为头结点

template <class T>
void List<T>::isHead(Node<T> *node)
{
    return node == _head;
}

3.判断节点是否为尾节点

template <class T>
void List<T>::isTail(Node<T> *node)
{
    return node->next == NULL;
}

4.获取链表的头结点

template <class T>
Node<T> *List<T>::getHead()
{
    return _head;
}

5.获取节点的尾节点

template <class T>
Node<T> *List<T>::getTail()
{
    Node<T> *tmpNode = _head;
    while(tmpNode->next)
    {
        tmpNode = tmpNode->next;
    }
    return tmpNode;
}

6.查找节点

template <class T>
Node<T> *List<T>::find(T val)
{
    Node<T> *tmpNode = _head->next;
    while(tmpNode)
    {
        if (tmpNode->val == val)
        {
            return tmpNode;
        }
        tmpNode = tmpNode->next;
    }
    return NULL;
}

7.查找上一个节点

template <class T>
Node<T> *List<T>::findPrevious(T val)
{
    Node<T> *tmpNode = _head;
    while(tmpNode->next)
    {
        if (tmpNode->next->val == val)
        {
            return tmpNode;
        }
        tmpNode = tmpNode->next;
    }
    return NULL;
}

8.在指定节点之后插入新节点

template <class T>
void List<T>::insert(Node<T> *node, T val)
{
    Node<T> *tmpNode = _head->next;
    while(tmpNode)
    {
        if (tmpNode == node)
        {
            Node<T> *newNode = new Node<T>();
            newNode->val = val;
            newNode->next = tmpNode->next;
            tmpNode->next = newNode;
            return;
        }
        tmpNode = tmpNode->next;
    }
}

9.在链表尾部插入节点

template <class T>
void List<T>::append(T val)
{
    Node<T> *newNode = new Node<T>();
    newNode->val = val;
    Node<T> *tail = getTail();
    tail->next = newNode;
}

10.删除节点

template <class T>
void List<T>::remove(T val)
{
    Node<T> *prevNode = findPrevious(val);

    if (prevNode)
    {
        Node<T> *tmpNode = prevNode->next;
        prevNode->next = prevNode->next->next;
        delete tmpNode;
    }
}

11.反转链表

template <class T>
void List<T>::reverse()
{
    Node<T> *tmpNode = _head->next;
    Node<T> *prevNode = NULL;
    while(tmpNode)
    {
        Node<T> *nextNode = tmpNode->next;
        tmpNode->next = prevNode;
        prevNode = tmpNode;
        tmpNode = nextNode;
    }
    _head->next = prevNode;
}

12.获取链表的节点数

template <class T>
int List<T>::size()
{
    Node<T> *tmpNode = _head->next;
    int n = 0;
    while(tmpNode)
    {
        tmpNode = tmpNode->next;
        n++;
    }
    return n;
}

13.删除整个链表

template <class T>
void List<T>::clear()
{
    Node<T> *tmpNode = _head->next;
    while(tmpNode)
    {
        Node<T> *node = tmpNode;
        tmpNode = tmpNode->next;
        delete node;
    }
    _head->next = NULL;
}

14.打印链表的所有节点

template <class T>
void List<T>::print()
{
    Node<T> *tmpNode = _head->next;
    while(tmpNode)
    {
        std::cout << tmpNode->val;//类型T需要重载输出流操作符
        <<
        tmpNode = tmpNode->next;
        if (tmpNode)
        {
            std::cout << " ";
        }
    }
    std::cout << std::endl;
}