数据结构整理（一） —— 链表的各种操作

    马上要面临大规模的面试了，用了太久标准库，已经对数据结构的内部实现快忘了，趁着还有几天时间，自己又回忆了一下，用C++实现出来。所以接下来我在博客中会写一个“数据结构整理”系列，在面试之前，能回忆多少算多少吧，希望面试官能感受到我曾经是一个对数据结构很熟悉的人。。。

    下面进入正题。

    链表和数组都是线性表，数组就不多说了，说一下链表的实现。链表的名字很形象，就是一个一个的结点链在一起，必须找到一个结点的父节点，才能找到该结点，链表一般都有一个头结点，而且头结点一般不保存用户的数据，只是为了方便对链表的寻址。另外，可以在头结点中保存一些额外的信息，例如链表的长度，不过为了可读性，我个人不建议这样做。

    下面是链表中一个结点的一般结构：

template <typename T>
class Node {
public:
    T data;
    Node *next;
    Node(T d) {
        data = d;
        next = nullptr;
    }
    Node() {
        next = nullptr;
    }
};

    data字段保存结点中需要存储的信息，next指针保存下一个结点的地址。

    一般在链表中都有一个头指针和一个尾指针，头指针始终指向头结点，作用是方便对链表寻址。尾指针指向链表最后一个结点，作用是减少插入数据时消耗的时间。对链表的操作一般有获取长度，插入结点，删除结点，排序，逆置等，所以链表的一般结构如下：

template <typename T>
class LinkList {
private:
    Node<T>* head;
    Node<T>* rear;
    int lenth;
public:
    LinkList();
    ~LinkList();
    inline int size();
    void insert(T data);
    void remove(T data);
    void sort();
    void reverse();
    void getArray(T*& arr);
};

    一个链表初始只有一个头结点，头指针和尾指针都指向头结点，链表长度为0。另外由于每个结点都是动态申请的堆内存，在析构函数中应及时释放，所以下面是构造函数和析构函数的实现：

template <typename T>
LinkList<T>::LinkList() {
    head = new Node<T>();
    head->next = nullptr;
    rear = head;
    lenth = 0;
}

template <typename T>
LinkList<T>::~LinkList() {
    Node<T>* cur = head->next;
    while(cur != nullptr) {
        delete head;
        head = cur;
        cur = cur->next;
    }
}

    向链表中插入数据即把新结点添加到链表末尾，所以利用尾指针可以很方便的做到。删除数据时先将待删除结点的父节点next的指针指向待删除结点的子节点，然后释放掉待删除结点的内存。下面是链表结点的插入和删除操作的实现：

template <typename T>
void LinkList<T>::insert(T data) {
    Node<T>* cur = new Node<T>(data);
    rear->next = cur;
    rear = cur;
    lenth++;
}

template <typename T>
void LinkList<T>::remove(T data) {
    Node<T>* before = head;
    Node<T>* cur = head->next;
    while(cur != nullptr) {
        if(cur->data == data) {
            before->next = cur->next;
            delete cur;
            cur = before->next;
            lenth--;
        } else {
            before = cur;
            cur = cur->next;
        }
    }
}

    链表的排序复杂度很高，一般不建议对存在大量数据的链表执行排序操作，链表的排序是一个对链表重建的过程，每次拆下一个结点，按照一定的顺序重新组合回去。注意排序完成后，尾指针一定要指向链表的最后一个结点。下面是链表排序的实现：

template <typename T>
void LinkList<T>::sort() {
    Node<T>* p = head->next;
    head->next = nullptr;
    rear = head;
    Node<T>* before = head;
    Node<T>* after = head->next;

    while(p != nullptr) {
        if(after == nullptr ||
            (p->data >= before->data && p->data <= after->data)) {
            before->next = p;
            p = p->next;
            before = before->next;
            before->next = after;
            before = head;
            after = head->next;
            if(rear->next != nullptr) {
                rear = rear->next;
            }
        } else {
            before = before->next;
            after = after ->next;
        }
    }
}

    链表的逆置也是一个重建链表的过程，即改变每个结点的指向，但是头结点依然是头结点。显然，逆置操作之后，尾指针应指向逆置前的第一个数据结点（即头指针的子结点）。下面是逆置操作的实现：

template <typename T>
void LinkList<T>::reverse() {
    if(lenth < 2) {
        return;
    }
    rear = head->next;
    Node<T>* before = head->next;
    Node<T>* after = before->next;
    head->next = nullptr;
    while(before != nullptr) {
        before->next = head->next;
        head->next = before;
        before = after;
        if(after != nullptr) {
            after = after->next;
        }
    }
}

    还有头文件中的另外两个函数，获取长度和转化为数组。获取长度很简单，在插入和删除时维护长度字段即可，为了提高在for循环中使用size()函数的效率，声明成inline的。转化为数组即遍历链表，把数据依次插入数组中即可。注意，C++不应返回一个函数中局部变量的数组，因为函数返回后栈被释放，非常危险。下面是获取长度和转化为数组的实现：

template <typename T>
int LinkList<T>::size() {
    return lenth;
}

template <typename T>
void LinkList<T>::getArray(T*& arr) {
    arr = new int[lenth];
    Node<T>* cur = head->next;
    for(int i = 0; cur != nullptr; i++) {
        arr[i] = cur->data;
        cur = cur->next;
    }
}

   最后附上单元测试的代码：

void test_linklist() {
    int number[] = {4, 2, 6, 7, 1, 4, 7};
    LinkList<int>* list = new LinkList<int>();
    for(int i = 0; i < 7; i++) {
        list->insert(number[i]);
    }

    int* arr = nullptr;
    list->getArray(arr);
    cout << "init:" << endl;
    for(int i = 0; i < list->size(); i++) {
        cout << arr[i] << endl;
    }
    delete arr;

    list->sort();
    list->getArray(arr);
    cout << "after sort:" << endl;
    for(int i = 0; i < list->size(); i++) {
        cout << arr[i] << endl;
    }
    delete arr;

    list->reverse();
    list->getArray(arr);
    cout << "after reverse:" << endl;
    for(int i = 0; i < list->size(); i++) {
        cout << arr[i] << endl;
    }
    delete arr;

    list->remove(4);
    list->getArray(arr);
    cout << "after remove 4:" << endl;
    for(int i = 0; i < list->size(); i++) {
        cout << arr[i] << endl;
    }
    delete arr;

    delete list;
}