数据结构——线性结构（3）——链栈的实现

链栈的实现

基于上一篇的内容，我们就直接上我们的实现文件，对于里面的实现，边画图边理解：

Stack.h文件

/*
 *这部分文件实现我们之前所使用的stack类
 *它主要的原理为 后进先出（LIFO）
 */

 #ifndef _Stack_h
 #define _Stack_h

 /*
  *类型: Stack<ValueType>
  *此类建立一个称为堆栈的线性结构，其中仅从一端添加和删除值。
  *这个规定产生了一个（LIFO）的行为，它是堆栈的定义特征。 
  *基本堆栈操作是push（添加元素到顶部）和pop（把元素从顶部删除）。
  */
 template <typename ValueType>
 class Stack{
    public:
        /*
         *构造函数：Stack
         *用法：Stack <ValueType> stack
         *-----------------------------
         *初始化一个空栈
         */
        Stack();
        //析构函数
        ~Stack();
        /*
         *方法：size（）
         *用法：int n = stack.size();
         *--------------------------
         *返回栈中元素的个数
         */
        int size();
        /*
         *方法：isEmpty（）
         *用法：stack.isEmpty();
         *--------------------------
         *判断栈中元素是否为空 
         */ 
        bool isEmpty();
        /*
         *方法：clear（）
         *用法：stack.clear();
         *--------------------------
         *清空栈中的所有元素 
         */ 
        void clear();
        /*
         *方法：push（）
         *用法：stack.push();
         *--------------------------
         *向栈顶推入一个元素 
         */ 
        void push(ValueType);
        /*
         *方法：pop（）
         *用法：stack.pop();
         *--------------------------
         *移除栈顶的一个元素,并返回其值，如果栈空 则返回一个错误 
         */
        ValueType pop(); 
        /*
         *方法：peek（）
         *用法：stack.peek();
         *--------------------------
         *返回栈顶的值，但是不移除，peek 偷看的意思,如果栈空 则返回一个错误
         */ 
         ValueType peek(); 

         #include "stackpriv.h" //私有成员部分


 };

 #include "stackimpl.cpp" //将实现文件包含进来 

#endif

私有成员部分

private:
    /*栈的链表结构*/
    struct Cell{
        ValueType data;
        Cell *link;
    };
    /*实例化变量*/
    Cell *stack; /*定义一个cell类型的指针，指向栈顶*/
    int count;   /*用返回栈中的元素个数*/

    /* Make it illegal to copy stacks */
    Stack(const Stack & value) { }
    const Stack & operator=(const Stack & rhs) { return *this; }

实现部分

/*
 *这个文件用于实现Stack头文件中定义的一系列的方法
 */
#ifdef _Stack_h
#include "error.h"

/*构造函数*/
template <typename ValueType>
Stack<ValueType>::Stack(){
    stack = NULL;
    count = 0;
}
/*析构函数*/
template <typename ValueType>
Stack<ValueType>::~Stack(){
    clear();
}
/*返回栈的大小*/
template <typename ValueType>
int Stack<ValueType>::size(){
    return count;
}
/*判断栈是否为空*/
template <typename ValueType>
bool Stack<ValueType>::isEmpty(){
    return count == 0;
}
/*清空栈*/
template <typename ValueType>
void Stack<ValueType>::clear(){
    if (count > 0)
    {
        pop();
    }
}
/*入栈，边画图边写代码理解*/
template <typename ValueType>
void Stack<ValueType>::push(ValueType element){
    Cell *cell = new Cell;
    cell -> data = element;
    cell -> link = stack;//指向栈顶的第二号元素，也就是头结点的指针
    stack = cell; //然后头结点指向这个节点
    count++;
}
/*出栈操作*/
template <typename ValueType>
ValueType Stack<ValueType>::pop(){
    if (isEmpty()) error("pop: Attempting to pop an empty stack");
    Cell *cell = stack; //定义一个指针 指向头结点所指的节点
    ValueType nReturn = cell -> data; //保存这个数据 以便返回
    stack = stack -> link; //改变头结点的指向
    count--; //栈长减一
    delete cell; //执行删除操作
    return nReturn;//返回栈顶值
}
/*查看栈顶元素*/
template <typename ValueType>
ValueType Stack<ValueType>::peek(){
    if (isEmpty()) error("peek: Attempting to peek at an empty stack");
    return stack -> data;
}

#endif

测试部分

#include <iostream>
#include "Stack.h" 
using namespace std;
int main(){
    Stack<int> mystack;
    for (int i = 0; i < 10; i++)
    {
        mystack.push(i);
    }
    cout << "栈顶元素为：" << mystack.peek() << endl;
    cout << "栈中共有" << mystack.size() << "个元素" << endl;
    int n = mystack.pop();
    cout << "出栈的元素为：" << n << endl;
    cout << "此时栈顶的元素为：" << mystack.peek() << endl;
    mystack.push(100);
    cout << "压入100后，此时的栈顶为：" << mystack.peek() << endl;
    mystack.clear();
    cout << "清空栈后，栈中的元素个数为：" << mystack.size() << endl;
    mystack.pop();
    return 0;   
}

测试结果