0. 資料結構圖文解析系列

1. 線性表簡介

線性表是一種線性結構，它是由零個或多個數據元素構成的有限序列。線性表的特徵是在一個序列中，除了頭尾元素，每個元素都有且只有一個直接前驅，有且只有一個直接後繼，而序列頭元素沒有直接前驅，序列尾元素沒有直接後繼。
資料結構中常見的線性結構有陣列、單鏈表、雙鏈表、迴圈連結串列等。線性表中的元素為某種相同的抽象資料型別。可以是C語言的內建型別或結構體，也可以是C++自定義型別。

2. 陣列

陣列在實際的實體記憶體上也是連續儲存的，陣列有上界和下界。C語言中定義一個數組：

陣列下標是從0開始的，a[0]對應第一個元素。其中，a[0]稱為陣列a的下界，a[6]稱為陣列a的上屆。超過這個範圍的下標使用陣列，將造成陣列越界錯誤

3. 單向連結串列

單向連結串列是連結串列的一種。連結串列由節點所構成，節點內含一個指向下一個節點的指標，節點依次連結成為連結串列。因此，連結串列這種資料結構通常在實體記憶體上是不連續的。連結串列的通常含有一個頭節點，頭節點不存放實際的值，它含有一個指標，指向存放元素的第一個節點。

3.1 單向連結串列的節點結構

//節點結構
template <typename T>
class Node
{
public :
    T _value;
    Node* _next;
public:
    Node() = default;
    Node(T value, Node * next)
        : _value(value), _next(next){}
};

1. _value: 節點的值
2. _next： 指標，指向下一個節點

3.2 單向連結串列的抽象資料結構

//單鏈表
template <typename T>
class SingleLink
{
public:
    typedef Node<T>*  pointer;
    SingleLink();
    ~SingleLink();
 
    int size();                         //獲取長度
    bool isEmpty();                     //判空
 
    Node<T>* insert(int index, T t); //在指定位置進行插入
    Node<T>* insert_head(T t);         //在連結串列頭進行插入
    Node<T>* insert_last(T t);         //在連結串列尾進行插入
 
    Node<T>*  del(int index);         //在指定位置進行刪除
    Node<T>*  delete_head();         //刪除連結串列頭
    Node<T>*  delete_last();         //刪除連結串列尾
 
    T get(int index);                 //獲取指定位置的元素
    T get_head();                     //獲取連結串列頭元素
    T get_last();                     //獲取連結串列尾元素
 
    Node<T>* getHead();                 //獲取連結串列頭節點
 
private :
    int count;
    Node<T> * phead;                
 
private :
    Node<T> * getNode(int index);      //獲取指定位置的節點
};
 

1. phead: 連結串列的頭節點。
2. count: 連結串列元素個數。

3.3 單鏈表新增節點

連結串列的插入元素操作時間複雜度O（1），只需要進行指標的指向修改操作。

在2之後新增7：

1. 為元素7構建節點 。
2. 將節點2 的next指標指向節點7。
3. 將節點7的next指向節點3。（節點3 的位置要先保留起來）

/*
在指定位置插入新節點
*/
template <typename T>
Node<T>* SingleLink<T>::insert(int index, T t)
{
    Node<T> * preNode = getNode(index);
    if (preNode)
    {
        Node<T> *newNode = new Node<T>(t,preNode->_next);
        preNode->_next = newNode;
        count++;
        return newNode;
    }
    return nullptr;
};
/*
從頭部插入
*/
template <typename T>
Node<T>* SingleLink<T>::insert_head(T t)
{
    return insert(0, t);
};
/*
從尾部進行插入
*/
template <typename T>
Node<T>* SingleLink<T>::insert_last(T t)
{
    return insert(count, t);
};

3.4 單鏈表刪除節點

單鏈表的刪除操作同樣是一個時間複雜度O（1）的操作，它也只需要修改節點的指標指標後即可銷燬被刪除節點。
例如我們刪除連結串列元素7：

相應的程式碼：

/*
刪除連結串列指定位置元素
*/
template <typename T>
Node<T>* SingleLink<T>::del(int index)
{
    if (isEmpty())
        return nullptr;
    Node<T>* ptrNode = getNode(index);
    Node<T>* delNode = ptrNode->_next;
    ptrNode->_next = delNode->_next;
    count--;
    delete delNode;
    return ptrNode->_next;
};
/*
刪除頭節點
*/
template<typename T>
Node<T>* SingleLink<T>::delete_head()
{
    return del(0);
};
/*
刪除尾節點
*/
template<typename T>
Node<T>*SingleLink<T>::delete_last()
{
    return del(count);
};

3.5 單鏈表程式碼測試

int main()
{
    SingleLink<int> link;
    for (int i = 0; i < 10; i++)
    {
        link.insert(i, i);
    }
    cout << link.size() << endl;
 
    link.insert_head(1111);
    link.insert_last(2222);
 
    SingleLink<int>::pointer ptr = link.getHead();
    while (ptr != nullptr)
    {
        cout << ptr->_value << endl;
        ptr = ptr->_next;
    }
 
    getchar();
    return 0;
}

測試結果：

10
1111
0
1
2
3
4
5
6
7
8
9
2222

其他的操作較為簡單，不在這裡貼出程式碼，文章底部有完整連結串列類的程式碼連結。

4. 雙向連結串列

單鏈表的節點連結是單方向的，要得到指定節點的前一個節點，必須從頭遍歷連結串列。
雙向連結串列是連結串列的一種。與單鏈表一樣，雙向節點由節點連結而成，每個節點含有兩個指標，分別指向直接前驅與直接後繼。從雙向連結串列的任何一個節點開始都能夠遍歷整個連結串列。
我們將雙向連結串列實現為雙向迴圈連結串列，也即是最後一個元素的後繼將指向頭節點，整個連結串列形成一個迴圈
例如，我們為元素1，2，3，4，5 構建一個雙向迴圈連結串列

在圖中：
表頭為空。
表頭的前驅節點是節點5，表頭的後繼節點是節點1；
節點1的前驅節點是表頭，節點1的後繼節點是節點2；
節點2的前驅節點是節點1，節點2的後繼節點是節點3；
...

4.1 雙向連結串列節點結構

雙向迴圈的節點中，比單向連結串列中多了一個指向直接前驅的指標

/*
雙向連結串列的節點結構
*/
template <typename T>
struct Node
{
public:
    Node()= default;
    Node(T value, Node<T>* preptr, Node<T>* nextptr)
        :_value(value), pre_ptr(preptr), next_ptr(nextptr){}
 
public:
    T _value;
    Node<T>* pre_ptr;
    Node<T>* next_ptr;
};

1. _value: 節點元素的值
2. pre_ptr:指向直接前驅的指標
3. next_ptr:指向直接後繼的指標

4.2 雙向連結串列的抽象資料結構

雙向連結串列類的定義與單鏈表相似。

/*
* 雙向連結串列類
*/
template<typename T>
class DoubleLink
{
public:
    typedef Node<T>* pointer;
public:
    DoubleLink();
    ~DoubleLink(){};
public:
    Node<T>* insert(int index, T value);
    Node<T>* insert_front(T value);
    Node<T>* insert_last(T value);
 
    Node<T>* del(int index);
    Node<T>* delete_front();
    Node<T>* delete_last();
 
    bool isEmpty();
    int size();
 
    T get(int index);
    T get_front();
    T get_last();
    Node<T>* getHead();
 
private:
    Node<T>* phead;
    int count;
private :
    Node<T>* getNode(int index);
};

4.3 雙向連結串列新增節點

與單鏈表一樣，雙向連結串列新增節點的時間複雜度為O（1），它也只需要修改相關指標的指向。

/*
*將新節點插到第一個位置
*/
template <typename T>
Node<T>* DoubleLink<T>::insert_front(T value)
{
    Node<T>* newNode = new Node<int>(value, phead, phead->next_ptr);
    phead->next_ptr ->pre_ptr= newNode;
    phead->next_ptr = newNode;
    count++;
    return newNode;
};
/*
*將新節點插到連結串列尾部
*/
template <typename T>
Node<T>* DoubleLink<T>::insert_last(T value)
{
    Node<T> * newNode = new Node<int>(value, phead->pre_ptr, phead);
    phead->pre_ptr->next_ptr = newNode;
    phead->pre_ptr = newNode;
    count++;
    return newNode;
};
/*
*將節點位置插到index位置之前
*/
 
template <typename T>
Node<T>* DoubleLink<T>::insert(int index, T value)
{
    if (index == 0)
        return insert_front(value);
 
    Node<T>* pNode = getNode(index);
    if (pNode == nullptr)
        return nullptr;
    Node<T>* newNode = new Node<T>(value, pNode->pre_ptr, pNode);
    pNode->pre_ptr->next_ptr = newNode;
    pNode->pre_ptr = newNode;
    count++;
 
    return newNode;
};

4.4 雙向連結串列刪除節點

雙向連結串列的刪除操作時間複雜度為O（1）.我們刪除節點7：

/*
*刪除連結串列第一個節點
*返回刪除後連結串列第一個節點
*/
template<typename T>
Node<T>* DoubleLink<T>::delete_front()
{
    if (count == 0)
    {
        return nullptr;
    }
    Node<T>* pnode = phead->next_ptr;
    phead->next_ptr = pnode->next_ptr;
    pnode->next_ptr->pre_ptr = phead;
    delete pnode;
    count--;
    return phead->next_ptr;
};
/*
*刪除連結串列的末尾節點
*返回刪除後連結串列尾部元素
*/
template<typename T>
Node<T>* DoubleLink<T>::delete_last()
{
    if (count == 0)
    {
        return nullptr;
    }
    Node<T>*pnode = phead->pre_ptr;
    pnode->pre_ptr->next_ptr = phead;
    phead->pre_ptr = pnode->pre_ptr;
    delete pnode;
    count--;
    return phead->pre_ptr;
}
/*
*刪除指定位置的元素
*
*/
template <typename T>
Node<T>* DoubleLink<T>::del(int index)
{
    if (index == 0)
        return delete_front();
    if (index == count - 1)
        return delete_last();
    if (index >= count)
        return nullptr;
    Node<T>* pnode = getNode(index);
    pnode->pre_ptr->next_ptr = pnode->next_ptr;
    pnode->next_ptr->pre_ptr = pnode->pre_ptr;
 
    Node<T>* ptemp = pnode->pre_ptr;
    delete pnode;
    count--;
    return ptemp;
};

其他的介面實現都很簡單，這裡不再講解。下面有提供完整的工程專案及原始碼。

4.5 雙向連結串列程式碼測試

int main()
{
    DoubleLink<int> dlink;
    //插入測試
    for (int i = 0; i < 10; i++)
    {
        dlink.insert(0, i+10);
    }
    dlink.insert(0,  100);
    dlink.insert_last(1000);
    cout <<"連結串列長度:"<< dlink.size() << endl;
 
    //刪除測試
    dlink.delete_front();
    dlink.delete_last();
    dlink.del(3);
 
 
    DoubleLink<int>::pointer ptr = dlink.getHead();
    ptr = ptr->next_ptr;
    while (ptr != dlink.getHead())
    {
        cout << ptr->_value<<endl;
        ptr = ptr->next_ptr;
    }
 
    getchar();
    return 0;
}

測試結果：

連結串列長度:12
19
18
17
15
14
13
12
11
10

5. 單鏈表、雙向連結串列原始碼

另外宣告：

1. C++模板不支援分離編譯，因此類定義與成員函式的實現都在.h檔案中完成；
2. 可以看到程式碼中new一個新節點之後，並沒有使用(prt!=nullptr)來檢查記憶體分配是否成功，這是因為new失敗時直接丟擲異常，不同於C語言malloc記憶體分配失敗返回NULL。