【C++】容器适配器实现栈Stack的各种功能(入栈、出栈、判空、大小、访问所有元素等)

原创 2016年05月30日 17:18:06

容器适配器实现栈Stack的各种功能:


我们知道,顺序表的特点是:相对比于链表插入和删除数据方便,无需像链表一样遍历来访问。因此,我们用容器适配器选择顺序表的模型来实现栈的各种功能。

#include<iostream>
using namespace std;
#include<assert.h>

template<class T>
class SeqList
{
private:
    T* _array;
    size_t _size;
    size_t _capacity;
    
public:
    SeqList()
        :_array(NULL)
        , _size(0)
        , _capacity(0)
    {}

    SeqList(const SeqList<T>& s)
    {
        _array = new T[s._size];
        for (size_t i = 0; i < s._size; i++)
        {
            _array[i] = s._array[i];
        }
        _size = s._size;
        _capacity = s._size;
    }

    SeqList<T>& operator=(SeqList<T> s)
    {
        if (&s != this)
        {
            swap(_array, s._array);
            swap(_size, s._size);
            swap(_capacity, s._capacity);
        }
        return *this;
    }

    ~SeqList()
    {
        if (_array)
        {
            delete[] _array;
        }
    }

    //扩容
    void _CheckCapacity(size_t n)
    {
        if (n > _capacity)
        {
            _capacity = n > 2 * _capacity + 3 ? n : 2 * _capacity + 3;
            T* tmp = new T[_capacity];
            if (_array)
            { 
                               for (size_t i = 0; i < _size; i++)
                {
                    tmp[i] = _array[i];
                }
            }
            delete[] _array;
            _array = tmp;
        }
    }

    int Size()
    {
        return _size;
    }

    //打印
    void PrintSeqList()
    {
        for (size_t i = 0; i < _size; i++)
        {
            cout << _array[i] << "  ";
        }
        cout << endl;
    }

    //尾插
    void PushBack(const T& x)
    {
        _CheckCapacity(_size + 1);
        _array[_size++] = x;
    }

    //尾删
    void PopBack()
    {
        if (_size == 0)
        {
            return;
        }        
        else
        {
            --_size;
        }
    }

    //operator[]
    T& operator[](size_t index)
    {
        /*assert(index < _size);*/
        return _array[index];
    }

    //请求空间
    void Reserve(size_t n)
    {
        _CheckCapacity(n);
    }
};

template<class T, template<class> class Container = SeqList>
class Stack
{
public:
    //入栈
    void Push(const T& x)
    {
        _con.PushBack(x);
    }

    //出栈
    void Pop()
    {
        _con.PopBack();
    }

    //大小
    size_t Size()
    {
        return _con.Size();
    }

    //判空
    bool Empty()
    {
        return _con.Size() == 0;
    }

    //栈顶
    T& Top()
    {
        size_t size = _con.Size();
        assert(size > 0);
        return _con[size - 1];

    }
protected:
    Container<T> _con;
};


void TestStack()
{
    Stack<int> ss1;
    ss1.Push(1);
    ss1.Push(2);
    ss1.Push(3);
    ss1.Push(4);
    ss1.Push(5);

    //访问栈中所有元素
    while (!ss1.Empty())
    {
        cout << ss1.Top()<< "  ";
        ss1.Pop();
    }    
}

int main()
{
    TestStack();
    system("pause");
    return 0;
}


本文出自 “Han Jing's Blog” 博客,请务必保留此出处http://10740184.blog.51cto.com/10730184/1751099

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

数据结构:stack栈的初始化、入栈、出栈及显示栈元素

#include const int MAX=5; //假定栈中最多保存5个数据 //定义名为stack的类,其具有栈功能 class stack { //数据成员 ...

【每日一题】实现一个栈Stack,要求实现Push(出栈)、Pop(入栈)、Min(返回最小值的操作)的时间复杂度为O(1)

这道题有两种实现方式 方法一:用两个栈来实现 两个栈实现的主要思路是,一个栈存放数据,一个栈存放最小值。 压栈操作: (1)我们先向S1压栈一个数据 (2)再向S1压入第二个数据,如果此...

C++栈的初始化,入栈,出栈,获取栈顶元素等操作

栈的一些性质: 1.栈为空不可以出栈 2.栈顶元素先出 3.新元素插入栈顶 栈的初始化: #include #include using namespace std; template //模...

【栈队列】实现一个栈Stack,要求实现Push(出栈)、Pop(入栈)、Min(返回最小值的操作)的时间复杂度为O(1)

问题分析要记录从当前栈顶到栈底元素的最小值,很容易想到用一个变量,每push一个元素更新一次变量的值。那么问题来了,当执行pop操作时,上一次的最小值就找不到了。解决方法方法1、 使用一个栈。元素x...

实现一个栈Stack,要求实现Push(出栈)、Pop(入栈)、Min(返回最小值的操作)的时间复杂度为O(1)

思路: push: 利用两个栈,第一个栈顺序存放元素,第二个栈当为空时,先存入一个元素,再次存入时,如果要存放的元素比第二个栈顶的元素大,则不存入,小于或等于的时候存入,就能保证第二栈顶都是第一个栈中...

模拟实现一个Stack 要求实现Push(出栈)、Pop(入栈)、Min(返回最小值的操作)的时间复杂度为O(1)

模拟实现Stack,要求实现Push(出栈)、Pop(入栈)、Min(返回最小值的操作)的时间复杂度为O(1)。 思路: Min(返回最小值的操作)我们可以实现用一个辅助栈或者辅助数组来实...

【每日一题】实现一个栈Stack,要求实现Push(出栈)、Pop(入栈)、 Min(返回最小值的操作)的时间复杂度为O(1)

题目:实现一个栈Stack,要求实现Push(出栈)、Pop(入栈)、 Min(返回最小值的操作)的时间复杂度为O(1) 解决方法:使用两个栈_data和_min,_min做为辅助栈(每次压入_mi...

实现一个栈(元素遵守先入后出顺序),能够通过 min 方法在 O(1)时间内获取栈中的最小元素。同时,栈的基本操作:入栈(Push)、出栈(Pop),也是在O(1)时间内完成的

实现一个栈(元素遵守先入后出顺序),能够通过 min 方法在 O(1)时间内获取栈中的最小元素。同时,栈的基本操作:入栈(Push)、出栈(Pop),也是在O(1)时间内完成的。 此问题可分析为: 方...

顺序栈的定义、初始化、出栈、入栈等操作 C++代码实现 ——感想

原文地址:http://www.cnblogs.com/hackerain/archive/2010/10/11/2130450.html  #include using namespace...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)