線性表是我們學習資料結構所接觸的第一類資料結構，它是最基本，最簡單且最常用的資料結構。仔細想一下，在學習資料結構前，你應該有一門程式語言基礎。在你以往的程式設計中，‘陣列’這個東西一定沒少用吧，沒錯，陣列就是線性表的一種，最簡單最普通的線性表。以及連結串列，動態的分配記憶體是不是自由度感覺很高呢？其實想一下你在學程式語言時已經將線性表這類資料結構的基礎打好了哦

接下來我們開始介紹我們兩種常用的特殊線性表之一 — 棧

定義先擺上：限定僅在表尾進行插入和刪除操作的線性表
光看定義肯定是不能很好的理解，我們來舉個生活中常用的棧的例子：
手槍的子彈夾，我們往裡塞子彈的時候，最先塞進去的子彈被塞到了最底部，第一個射出的子彈應該是你最後塞進去的，這就是簡單的棧的例子。
從中我們看出棧的特性：後進先出 最先進棧的元素最後出棧。棧底就是彈夾底部，棧頂就是彈夾頂部射出子彈那端

現在我們理解了棧的性質，那麼我們要如何用計算機語言實現呢？
我們已經知道如何使用陣列這樣一個線性表，棧本質上就是對普通線性表加以限制，陣列可以在頭端增刪，也可在尾端增刪，那麼我們只需修改增刪的操作，把它限制成只能在一端增刪，不就成了？然後再將下標0的位置設為棧底，陣列尾部設為棧頂，我們就基本完成的棧這一資料結構的基本形態。

那麼接下來我們將棧這一資料結構用順序結構，也就是陣列實現

#include <iostream>
using namespace std;
/*棧的抽象資料型別*/
template<class T>
class Stack
{
private:
    int
 
 top;
    int bottom;
    int MAXSIZE;
    T *elements;
public:
    /*構造器將棧頂與棧底置0*/
    Stack()
    {
        this->MAXSIZE = 100;
        elements = new T[MAXSIZE];
        this->top = 0;
        this->bottom = 0;
    }
    ~Stack()
    {
        Destory();
    }
    /*入棧操作*/
    void Push(T e)
    {
        if
 
 (this->IsFull())
        {
            cout << "棧滿" << endl;
            return;
        }
        this->elements[top] = e;
        this->top++;
    }
    /*出棧操作，用e返回出棧元素*/
    void Pop(T &e)
    {
        if (this->IsEmpty())
        {
            cout << "空棧" << endl;
            return;
        }
        e = this->elements[top - 1];
        this->top--;
    }
    /*判斷是否為空棧*/
    bool IsEmpty()
    {
        if (this->top == this->bottom)
            return true;
        else return false;
    }
    /*判斷是否棧滿*/
    bool IsFull()
    {
        if (top == MAXSIZE)
            return true;
        else return false;
    }
    /*返回棧元素個數*/
    int Length()
    {
        return this->top;
    }
    /*獲取棧頂元素*/
    T GetTop()
    {
        return this->elements[top - 1];
    }
    /*將棧清空*/
    void Clear()
    {
        this->top = this->bottom;
    }
    /*銷燬棧*/
    void Destory()
    {
        delete[]elements;
        this->top = this->bottom;
    }
    /*從底向上遍歷*/
    void Traverse()
    {
        for (int i = this->bottom; i < this->top; i++)
        {
            cout << elements[i] << " ";
        }
    }
};

程式碼很簡單，我就一次性貼出來了。我們使用兩個指標top,bottom用來指向棧頂與棧底，最初的初始化操作將棧頂與棧頂置為下標0的位置。top始終指向棧頂元素的下一個位置，bottom指向0作為棧底
入棧過程入下圖所示：

接下來是出棧過程：
出棧過程只是下移棧頂指標，資料仍然存在但是無法訪問，接下來的入棧會將其再次覆蓋

棧空與棧滿的兩種狀態：
top==bottom==0時棧空，top==MaxSize時top指到頭了也就是棧滿

怎麼樣，是不是很簡單呢？這完全就是對陣列的基本操作。相信有程設計語言基礎的你可以輕鬆理解。
使用陣列來儲存棧是很方便的，因為限制了增刪的位置在末尾，所以不用擔心修改的時間效率。但是陣列的不可避免的弊端就是必須事先確定棧的大小，如果棧滿就需要程式設計的方式擴充大小。這時你可能想到使用連結串列，沒錯，連結串列的動態增刪是一個很好的選擇，但是在介紹鏈棧之前我要先介紹另一個提高空間利用率的手段：兩棧共享空間
假設現在需要使用兩個相同型別的棧，如果各自開闢一個數組，會出現一種情況，一個棧滿了，但另一個棧還有剩餘空閒，所以我們為什麼不想辦法利用空閒的空間呢? 因此我們可以通過某種手段，讓這兩個棧共享一個空間。

如圖，我們的思路就是將兩個棧頂指標放在陣列兩端，入棧時不斷向中間移動，我們可以很容易的知道當top1==top2時棧滿
接下來是程式碼的實現，與單棧的差別就是少了bottom指標，多了個top指標，多了個列舉型別標記選擇要操作哪個棧

#include<iostream>
using namespace std;
/*棧名標識*/
enum StackNum
{
    first, second
};
template<class T>
class ShStack
{
private:
    int top1;
    int top2;
    int MAXSIZE;
    T *elements;
public:
    /*初始化*/
    ShStack()
    {
        this->top1 = 0;
        this->MAXSIZE = 100;
        this->top2 = this->MAXSIZE - 1;
        this->elements = new T[this->MAXSIZE];
    }
    /*進棧*/
    void Push(T e, StackNum num)
    {
        if (this->IsFull())
        {
            cout << "棧滿" << endl;
            return;
        }
        if (num == first)
        {
            this->elements[this->top1] = e;
            this->top1++;
        }
        else
        {
            this->elements[this->top2] = e;
            this->top2--;
        }
    }
    /*出棧*/
    void Pop(T &e, StackNum num)
    {
        if (this->IsEmpty())
        {
            cout << "空棧" << endl;
            return;
        }
        if (num == first)
        {
            e = this->elements[this->top1 - 1];
            this->top1--;
        }
        else
        {
            e = this->elements[this->top2 + 1];
            this->top2++;
        }
    }
    /*獲取棧頂元素*/
    T GetTop(StackNum num)
    {
        if (num == first)
            return this->elements[this->top1 - 1];
        else if (num == second)
            return this->elements[this->top2 + 1];
    }
    /*獲取棧長*/
    int Length(StackNum num)
    {
        if (num == first)
            return this->top1;
        else if (num == second)
            return this->MAXSIZE - this->top2;
    }
    /*判斷是否棧滿*/
    bool IsFull()
    {
        if (this->top1 == this->top2)
            return true;
        else return false;
    }
    /*判斷是否為空棧*/
    bool IsEmpty()
    {
        if (this->top1 == 0 && this->top2 == this->MAXSIZE - 1)
            return true;
        else return false;
    }
    /*從底向上遍歷*/
    void Traverse(StackNum num)
    {
        if (num == first)
        {
            for (int i = 0; i < this->top1; i++)
                cout << this->elements[i] << " ";
        }
        else if (num == second)
        {
            for (int i = this->MAXSIZE - 1; i > this->top2; i--)
                cout << this->elements[i] << " ";
        }
    }
    /*銷燬棧*/
    void Destory()
    {
        delete[]elements;
        top1 = 0;
        top2 = MAXSIZE - 1;
    }
};

使用這樣的手段，需要兩個棧是相同型別，且具有空間需求相反的關係，一方增長，一方就縮短，這樣共享棧才有意義，否則兩棧同時增長，對於這種資料結構很容易快速滿棧，這樣不能很好的處理問題。因此在資料結構的設計時要根據具體情況與需求使用相應的處理策略，這樣才能更有效的利用空間