數據結構整理（一） —— 鏈表的各種操作

    馬上要面臨大規模的面試了，用了太久標准庫，已經對數據結構的內部實現快忘了，趁着還有幾天時間，自己又回憶了一下，用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;
}