基于Vector实现适配器stack(顺序栈)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_34021920/article/details/78463217

这里写图片描述
栈遵循先进后出,后进先出的原则,它的插入和删除都是在栈顶进行操作,是一种特殊的线性顺序表,因此,实现栈我们通常建立在顺序表的基础上。下来我们利用之前实现过的容器Vector中的一部分接口来实现stack
(在这里分别用了模板参数和模板的模板参数两种方式来实现来实现)

stack.h:

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include "Vector.h"
//模板参数
template<class T,class Container>
class Stack1
{
public:
    Stack1()//构造函数
    {}
    void Push(const T data)
    {
        _con.PushBack(data);
    }
    void Pop()
    {
        _con.PopBack();
    }
    bool Empty()
    {
        return _con.Empty();
    }
    size_t Size()
    {
        return _con.Size();
    }
    T& Top()
    {
        return _con.Back();
    }
    const T& Top()const
    {
        return _con.Back();
    }
private:
    Container _con;
};

//模板的模板参数
template<class T, template<class > class Container >
class Stack2
{
public:
    Stack2()//构造函数
    {}
    void Push(const T data)
    {
        _con.PushBack(data);
    }
    void Pop()
    {
        _con.PopBack();
    }
    bool Empty()
    {
        return _con.Empty();
    }
    size_t Size()
    {
        return _con.Size();
    }
    T& Top()
    {
        return _con.Back();
    }
    const T& Top()const
    {
        return _con.Back();
    }
private:
    Container<T> _con;
};

Vector.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <iostream>
using namespace std;
#include <assert.h>

template<class T>
class Vector
{
public:
    typedef T* Iterator;
    typedef const T* IteratorConst;
public:
    //无参构造函数
    Vector()
        :_start(0)
        , _finish(0)
        , _endOfStorage(0)
    {}
    //有参构造函数
    Vector(const T* array,size_t size)
        :_start(new T[size])
        , _finish(_start)
        , _endOfStorage(_start+size)
    {
        for (size_t i = 0; i < size; i++)
        {
            *_finish++ = array[i];
        }
    }
    //析构函数
    ~Vector()
    {
        if (_start)
        {
            delete[] _start;
            _start = 0;
            _finish = 0;
            _endOfStorage = 0;
        }
    }
    //尾插
    void PushBack(const T& data)
    {
        _CheckCapacity();
        *_finish++ = data;
    }
    //尾删
    void PopBack()
    {
            --_finish;
    }

    //获取有效元素个数
    size_t Size()const
    {
        return _finish - _start;
    }
    //判断是否为空
    bool Empty()const
    {
        return _start == _finish;
    }
    //返回尾元素
    T& Back()
    {
        assert(_start);
        return _start[Size() - 1];
    }
    const T& Back()const
    {
        assert(_start);
        //return _start[Size() - 1];
        return *(End() - 1);
    }
    //清空顺序表
    void Clear()
    {
        _finish = _start;
    }
private:
    //检查容量
    void _CheckCapacity()
    {
        T* temp;
        if (_finish == _endOfStorage)
        {
            size_t capacity = 2 * (_endOfStorage - _start) + 3;
            temp = new T[capacity];
            T* pos = _start;
            size_t i = 0;
            while (pos < _endOfStorage)
            {
                temp[i++] = *pos++;
            }
            delete _start;
            _start = temp;
            _finish = _start + i;
            _endOfStorage = _start + capacity;
        }
    }
    //重载输出运算符
    template<class T>
    friend ostream& operator<<(ostream& _cout, const Vector<T>& d)
    {
        for (size_t i = 0; i < d.Size(); i++)
        {
            _cout << d[i] << " ";
        }
        return _cout;
    }

private:
    T* _start;
    T* _finish;
    T* _endOfStorage;

};

测试代码:

void FunTest1()
{
    Stack1<int,Vector<int>> s1;
    for (int i = 0; i < 5; i++)
    {
        s1.Push(i);
    }
    while (!s1.Empty())
    {
        cout << s1.Top() << " ";
        s1.Pop();
    }
    cout << endl;
}
void FunTest2()
{

    Stack2<int,Vector> s1;
    for (int i = 0; i < 5; i++)
    {
        s1.Push(i);
    }
    while (!s1.Empty())
    {
        cout << s1.Top() << " ";
        s1.Pop();
    }
    cout << endl;
}
int main()
{
    FunTest1();
    FunTest2();
    system("pause");
    return 0;
}

读者可自行进行跟踪调试,看看结果

展开阅读全文

没有更多推荐了,返回首页