数据结构之栈的实现

1.定义：栈是仅限定在表的一端进行插入和删除操作的线性表。(因此，栈的本质仍是线性表)

符合LIFO(last in first out)特性，是后进先出的线性表。

2.相关定义：

        2.1  栈顶：允许进行插入和删除操作的一端。

        2.2  栈底：与栈顶相反的另一端。

        2.3  空栈：不含任何元素的栈。

3.相关操作：入栈，出栈

4.顺序栈:通过一维数组实现，示例代码如下

const int StackSize = 10;
template<typename T>
class SeqStack
{
private:
    int top;                    //栈顶元素下标
    T data[StackSize];          //存放栈内元素的数组
public:
    SeqStack();                 //无参构造函数
    ~SeqStack();                //析构函数
    void Push(T x);             //入栈操作，插入成功入栈否则返回错误信息
    T Pop();                    //出栈操作，删除栈顶元素并返回
    T GetTop();                 //取栈顶操作，返回当前栈顶元素
    bool Empty();               //判空操作
};


//无参构造函数的实现
template<typename T>
SeqStack::SeqStack()
{
    top = -1;
}

//析构函数实现
template<typename T>
SeqStack::~SeqStack(){}           //由于是静态存储，内存会自动释放，故无需销毁


//入栈操作实现
template<typename T>
void SeqStack::Push(T x)
{
    if(top == StackSize - 1) throw"上溢";
    else data[++top] = x;         //栈顶先加1为新数据获得空间再将新数据入栈
}


//出栈操作实现
template<typename T>
T SeqStack::Pop()
{
    if(top == -1) throw"下溢";
    else rreturn data[top--];
    //else语句可以等同于：
    //T x = data[top];
    //top--;
    //return x; 
}

//取栈顶操作
template<typename T>
T SeqStack::GetTop()
{
    return data[top];
}

//判空操作实现
template<typename T>
bool SeqStack::Empty()
{
    if(top == -1) return true;
    else return false;
}

小结：顺序栈比较简单，基础，其中需要区分的就是取栈顶和出栈操作，字面意思很容易区分理解

5.链栈：通过单链表实现栈的结构，示例代码如下

template<typename T>
struct Node
{
    T data;                //数据域
    int *next；            //指针域
};

template<typename T>
class LinkStack
{
private:
    Node<T> *top;          //链栈不需要附加头结点，因为只在栈顶一端进行操作
public:
    LinkStack();           //无参构造函数
    ~LinkStack();          //析构函数
    void Push(T x);        //入栈操作
    T Pop();               //出栈操作
    T GetHead();           //取栈顶操作
    bool Empty();          //判空操作
    void Print();          //遍历打印
};

//无参构造函数实现
template<typename T>
LinkStack::LinkStack()
{
    top = nullptr;
}

//析构函数实现
template<typename T>
LinkStack::~LinkStack()
{
    //法一：
    while(top != nullpte)
    {
        Node<T> *p = top;
        top = top->next;
        delete p;
    }
    //法二：
    //while(!Empty())
    //{
    //    Pop();
    //}
}

//入栈操作实现
template<typename T>
void LinkStack::Push(T x)
{
    Node<T> *p = nullptr;
    p = new Node<T>；            //此举用于申请空间
    p->data = x;
    p->next = top;
    top = p;
}

//出栈操作实现
template<typename T>
T LinkStack::Pop()
{
    if(top == nullptr) throw"下溢";
    Node *p = nullptr;
    p = new Node<T>;
    p = top;
    T x = top->data;
    top = top->next;
    delete p;
    return x;
}

//取栈顶操作
template<typename T>
T LinkStack::GetHead()
{
    T x = top->data;
    return x;
}

//判空操作实现
template<typename T>
bool LinkStack::Empty()
{
    if(top == nullptr) return true;
    return false;
}

//遍历打印操作的实现
template<typename T>
void LinkStack::Print()
{
    //法一：
    while(top != nullptr)
    {
        cout<< top->data << " ";
        top = top->next;  
    }
    //法二：
    // while(!Empty())
    //{
    //    cout<< Pop() << " "; 
    //}
}

小结：链栈的基本功能实现也比较简单，学会借助中间变量。