• 線性表
• 連結串列結構
• 堆疊
  • 1 順序棧
  • 2 鏈式棧
• 佇列
  • 1 順序佇列
  • 2 鏈式佇列
• 總結

線性表、連結串列以及佇列是在coding中最為常見的資料結構，在平時程式設計時，我們會有意識或無意識的進行選擇。

1. 線性表

線性表本質上是一種順序儲存結構，所有需要儲存的內容是可以被索引的，說起來，在程式設計時常用的陣列就是線性表的一種。
線性表的資料結構表示：

class LinearList 
{
    private:
        int MaxSize;      //線性表的最大尺寸
        int length;     //線性表的實際長度
 

        int *element;     //儲存線性表的陣列
                  //一般使用模板來代替int定義，這裡為了方便，使用int
    public:
        //線性表的建構函式，預設最大尺寸為10
        LinearList(int MaxSize = 10);
        ~LinearList() { delete[] element;  }

        bool IsEmpty()const { return length == 0; }
        bool IsFull()const { return length == MaxSize; }

        int
 
 Length()const { return length; }

        //線性表的存取函式，其中k表示索引號，item表示存取的資料值
        bool Find(int k, int &item)const;
        int Search(const int &item)const;
        void Delete(int k, int &item)const;
        void Insert(int k, const int &item);
}

不難看出，線性表的優勢在於隨機訪問的效率高，速度快（因為可以進行索引），而且實現起來較為簡單

，但是由於先行表的最大長度固定，所以想要增加線性表的長度並不容易，如果需要進行線性表的長度變化，可以建立一個新的線性表，並且將原始的線性表中的內容完全複製到新的線性表中，刪除原始線性表即可。

2. 連結串列結構

連結串列彌補了線性表的缺點，但是又增加了新的問題。看如下例程：

class Node
{
    private:
        int data;   //資料域，一般為模板類
        Node *next; //指向下一個結點
    public:
        Node(Node *nextNode = NULL) { next = nextNode; }
        Node(const int& item, Node *nextNode = NULL)
            { data = item;  next = nextNode; }
        void setData(int data);
        int Data() { return data; }
};

class LinkedList
{
    private:
        Node *head;  //頭指標
    public:
        LinkedList() { head = new Node(); }
        LinkedList(int &item);
        ~LinkedList();

        bool IsEmpty()const { return head->next == NULL; }
        int Length()const; //返回連結串列長度

        //這裡的實現多種多樣，此下幾個函式為其中一種
        //通過遍歷連結串列找到第k個元素，將該元素賦值給item
        bool Find(int k, int &item)const;
        int Search(int k, int &item)const;
        void Delete(int k, int &item)const;
        void Insert(int k, const int &item);
}

該程式結點只是連結串列的一種，單向連結串列。還有其他如，迴圈連結串列，雙向連結串列，十字連結串列等等。
迴圈連結串列中最後的一個元素的後繼結點為表頭結點，雙向連結串列中每個元素有兩個指標，分別指向其前驅結點與後繼結點。

Tip：
前驅結點：對於某一個結點來說，所有指向該結點的結點，就是該結點的前驅結點。
後繼結點：對於某一個結點來說，該結點所指向的下一個結點，就是該節點的後繼結點。

3. 堆疊

堆疊這一概念應該是分開的，堆是堆，棧是棧，兩種不同的東西。
棧的基本組成為棧頂指標，壓棧，彈棧動作，並且只能對棧頂元素進行讀寫操作，。其邏輯結構是先進棧的元素後讀出，後進入的元素先讀出，我們可以稱之為後來居上的原則（LIFO）。棧也僅僅是一種概念，其實現是由其他基本資料結構完成的。

在這裡只講棧，不講堆。

3.1 順序棧

順序棧，其實就是用線性表來實現的棧。
順序棧的主要思想是：建立一個線性表，棧頂指標為索引號，其值為當前棧頂的索引號，壓棧和彈棧的動作僅僅是對棧頂指標的值進行賦值和清除。

class AStack
{
    private:
        int size;     //線性表的長度
        int *stackArray;    //存放棧頂元素的陣列
        int top;    //棧頂指標
    public:
        AStack(int MaxStackSize = 10)
        {
            size = MaxStackSize;
            stackArray = new int[MaxStackSize];
            top = -1;
        }
        ~AStack()
        { delete[] stackArray; }

        bool Push(const int &item);   //壓棧
        bool Pop(int &item);     //彈棧
        bool Peek(int &item)const;      //讀取棧頂元素
        int IsEmpty()const { return top == -1; }
        int IsFull()const { return top == size - 1; }
        void clear() { top = -1; }

順序棧的優勢與線性表的優勢相同，都是實現簡單，效率高，缺點也是不易對棧進行擴充。

3.2 鏈式棧

聽名字就知道了，這種棧是以連結串列儲存結構實現的。

class LStack
{
    private:
        Node *top;   //指向棧頂指標
    public:
        LStack() { top = NULL; }
        ~LStack() { clear(); }
        void clear();   //清空棧

        bool Push(const int &item);
        bool Pop(int &item);
        bool Peek(int &item);
        int IsEmpty()const { return top == NULL; }
}

鏈式棧的優缺點可以與連結串列結構相似。

4. 佇列

佇列和堆疊的性質較為類似，只是佇列採取的原則是，先進先出原則（FIFO）。在佇列中所有的操作均只能對隊首與隊尾進行，而在實現上，也分為順序佇列以及鏈式佇列。

這種原則和日常排隊相像，先到先得。

4.1 順序佇列

使用順序儲存的方式實現，其主要思想為：
建立一個線性表，增加兩個指標，分別命名為隊首指標，指向佇列最開始的位置，並且元素由此出隊，隊尾指標，指向當前插入佇列的位置，並且只能向後插入。

其實佇列還可以增加一個指標，用於遍歷佇列中的元素，但是這樣做就破壞了佇列操作的原則，使佇列退化成了一個簡單的線性表。

class AQueue
{
    private:
        int front;     //隊首
        int rear;     //隊尾
        int count;    //佇列元素個數
        int *QArray;   //佇列陣列
        int size;    //佇列大小
    public:
        AQueue(int MaxQueueSize = 10);
        ~AQueue() { delete[] QArray; }

        bool QInsert(const int &item);    //向隊尾插入元素
        bool QDelete(int &item);     //刪除隊首元素

        void QClear() { front = rear = count = 0; }
        int QFront()const;    //讀取隊首元素
        bool IsEmpty()const { return count == 0; }
        bool IsFull()const { return count == size; }
}

4.2 鏈式佇列

思想和順序佇列類似，實現如下：

class LQueue
{
    private:
        Node *front, *rear;
    public:
        LQueue() { front = rear = NULL; }
        ~LQueue() { QClear(); }

        void QInsert(const int &item);
        bool QDelete(int &item);
        bool QFront(int &item);

        int IsEmpty()const { return front == NULL; }
        void QClear();

無論是堆疊還是佇列，上述幾種都是較為基礎的形式，關於堆疊和佇列，還有其相應的擴充套件，如雙端佇列，雙棧，超佇列，超棧等等。

5. 總結

資料結構是計算機開發中最為重要的一門知識，可以說，只要是程式設計，就會用到資料結構。
本文僅僅是資料結構的冰山一角，但是隨著程式設計的深入，你會發現，這冰山一角卻是冰山最重要的基礎。

資料結構的定義很廣，包括使用C語言或是其他語言編寫一個小的struct結構體，都可以被視為一中資料結構。
還是那句話，所有複雜的事物，都是由簡單的符號所組成的。