【数据结构】c++栈的实现

       栈是一种基于后进先出策略的集合类型。当你的邮件在桌上放成一叠时，使用的就是栈。新的邮件来到时你将它们放在最上面，当你有空时你会一封一封地从上到下阅读它们。这就是一种后进先出的情况。

栈的实现有两种，一种是顺序栈，一种是链式栈。顾名思义，顺序栈就是通过数组来实现，链式栈就是通过链表来实现的。

1.下面是顺序栈的代码实现：

template <class T> class FixedCapacityStack
{
public:
    FixedCapacityStack(int cap):
        N(0),length(cap)
    {
        a = new T [cap];
    }

    void isEmpty()
    {
        return N==0;
    }

    int size()
    {
        return N;
    }

    void resize(int max)
    {
        //将大小为N <= max的栈移动到一个新的大小为max的数组中
        T *temp = new T [max];
        for(int i = 0;i < N; ++i)
        {
            temp[i] = a[i];
        }
        a = temp;
        length = max;
    }

    //将元素压入栈顶
    void push(T item)
    {
        if(N == length)
            resize(2*length);
        a[N++] = item;
    }

    //从栈顶删除元素
    T pop()
    {
        T item = a[--N];
        if(N > 0 && N == length/4)
            resize(length/2);
        return item;
    }

private:
    T *a;
    int N;
    int length;

};

这里实现的是定长的顺序栈，就是创建的时候需要指定大小，当然后续可以进行resize进行设置大小；

resize的实现就是将栈移动到另外一个大小不同的数组中；

push()的实现，先检查数组是否太小，就是检查栈的大小N和数组的大小是否相等来检查数组是否能容纳新的元素。如果没有多余的空间，我们会将数组的长度加倍。

pop()的实现，首先先删除栈顶的元素，然后如果数组太大我们就将它的长度减半。检测条件是栈的大小是否小于数组的四分之一。在数组长度被减半之后，它的状态约为半满，在下次需要改变数组大小之前仍然能够进行多次push和pop操作。在这个实现中，栈永远不会溢出，使用率也永远不会低于四分之一（除非栈为空，那种情况下数组的大小为1）.

下面是实现的代码：

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    int b[10] = {0};

    int length = sizeof (b)/sizeof (int);

    FixedCapacityStack<int> intStack(100);
    for(int i = 0; i < 10; ++i)
    {
        intStack.push(i);
    }

    for(int i = 0; i < 10; ++i)
    {
        cout << intStack.pop() << endl;
    }


    return a.exec();
}

运行的结果为：

这里遇到一个问题就是使用

sizeof(a)/sizeof(T)

去数组的大小取到的都是1，不懂是为什么，没找到原因。所以另外定义了一个成员变量length来记录。

2.链式栈

首先先看代码实现：

template<class T> class Stack
{
public:
    Stack():
        N(0)
    {

    }

    bool isEmpty(){ return first == nullptr;}

    int size() {return N;}

    //向栈顶添加元素
    void push(T item)
    {
        Node *oldFirst = first;
        first = new Node();
        first->item = item;
        first->next = oldFirst;
        N++;
    }

    T pop()
    {
        T item = first->item;
        Node *temp = first->next;
        delete first;
        first = temp;
        N--;
        return item;
    }

private:

    struct Node
    {
        T item;
        Node *next = nullptr;
    };

    Node *first = nullptr;
    int N;


};

这份泛型的栈实现的基础是链表数据结构，用的是一个单链表。它可以用于创建任何数据类型的栈。

其中push就是在链表的头部插入新节点，而pop就是在删除链表的头节点。具体操作操作就是单链表的操作，直接看代码。

下面是运用代码：

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Stack<int> stack = Stack<int>();
    for(int i = 0; i < 10; ++i)
    {
        stack.push(i);
    }
    for(int i = 0; i < 10; ++i)
    {
        cout << stack.pop() << endl;
    }

    return a.exec();
}

运行结果如下：