(C++)栈和队列的模拟实现

标签: c++ 栈和队列 线性表
159人阅读 评论(0) 收藏 举报
分类:

什么是栈?

栈(stack)是限定仅在表尾进行插入和删除操作的线性表

我们把允许插入和删除的一端称为栈顶(Top),另一端称为栈底(bottom),不含任何数据原色的栈称为空栈。栈又称为后进先出(Last In First Out)的线性表,简称LIFO结构。

实现一个栈

代码实现:

template <class T>
class stack
{
public:
    stack()
        :_data(NULL)
        , _size(0)
        , _capacity(0)
    {}

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

    ~stack()
    {
        if (_data)
        {
            delete[] _data;
            _data = NULL;
            _size = 0;
            _capacity = 0;
        }
    }

    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            size_t _newCapacity = _capacity * 2 + 3;
            T* tmp = new T[_newCapacity];
            assert(tmp);
            for (size_t i = 0; i < _size; ++i)
            {
                tmp[i] = _data[i];
            }

            delete[] _data;
            _data = tmp;
            _capacity = _newCapacity;
        }
    }

    void Push(const T& x)
    {
        if (_size == _capacity)
        {
            CheckCapacity();
        }

        _data[_size] = x;
        _size++;

    }

    void Pop()
    {
        assert(_size);
        --_size;
    }

    T& Top()
    {
        return _data[_size-1];
    }

    bool Empty()
    {
        return (_size == 0);
    }

private:
    T* _data;
    size_t _size;
    size_t _capacity;
};

测试用例:

void Test1()
{
    stack<int> mystack;
    mystack.Push(1);
    mystack.Push(2);
    mystack.Push(3);
    mystack.Push(4);

    mystack.Pop();
    mystack.Pop();
    mystack.Pop();

    while (!mystack.Empty())
    {
        cout << mystack.Top() << ' ';
        mystack.Pop();
    }

    cout << endl;
}

实现结果:

这里写图片描述

队列

什么是队列?

队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。

队列是一种先进先出(First In First Out)的线性表,简称FIFO。我们将允许插入的一端称为队尾,允许删除的一端称为队头。

实现一个队列

代码实现:

template<class T>
struct ListNode
{
    T _data;
    ListNode* _next;

    ListNode(const T& x)
        :_data(x)
        , _next(NULL)
    {}
};


template<class T>
class queue
{
    typedef ListNode<T> Node;
public:
    queue()
    {
        _head = new Node(T());//匿名对象
        _head->_next = NULL;
    }

    queue(const queue<T>& q)
    {
        Node* cur = q._head;

        while (cur)
        {
            Push(cur->_data);
            cur = cur->_next;
        }

    }

    ~queue()
    {
        Node* cur = _head;
        while (cur)
        {
            Node* tmp = cur;
            cur = cur->_next;
            delete tmp;
        }
        _head = NULL;
    }

    void Push(const T& x)
    {
        Node* tmp = new Node(x);
        Node* cur = _head;
        while (cur->_next)
        {
            cur = cur->_next;
        }
        cur->_next = tmp;
        tmp->_next = NULL;
    }

    void Pop()
    {
        Node* cur = _head->_next;
        Node* tmp = cur;

        _head->_next = tmp->_next;
        delete tmp;
    }

    T& Back()
    {
        Node* cur = _head;

        while (cur->_next)
        {
            cur = cur->_next;
        }

        return cur->_data;
    }

    T& Front()
    {
        return _head->_next->_data;
    }

    bool Empty()
    {
        return (_head->_next == NULL);
    }

    void Print()
    {
        Node* cur = _head->_next;
        while (cur)
        {
            cout << cur->_data << ' ';
            cur = cur->_next;
        }
        cout << endl;
    }

private:
    Node* _head;
};

测试用例:

void Test2()
{
    queue<int> myqueue;
    myqueue.Push(1);
    myqueue.Push(2);
    myqueue.Push(3);
    myqueue.Push(4);
    myqueue.Push(5);
    myqueue.Push(6);

    myqueue.Print();

    while (!myqueue.Empty())
    {
        cout << myqueue.Front() << ' ';
        myqueue.Pop();
    }
    cout << endl;

    myqueue.Push(1);
    myqueue.Push(2);
    myqueue.Push(3);
    myqueue.Push(4);
    myqueue.Push(5);
    myqueue.Push(6);

    myqueue.Pop();
    myqueue.Pop();
    myqueue.Pop();

    myqueue.Print();

    cout << myqueue.Front() << ' ';
    cout << endl;

    cout << myqueue.Back() << ' ';
    cout << endl;
}

实现结果:

这里写图片描述

查看评论

模拟停车场管理系统。利用栈和队列来实现

  • 2009年11月30日 13:16
  • 7KB
  • 下载

栈和队列(用C++实现栈和队列)

栈是一种后进先出的线型结构,C++实现栈的代码如下: #include using namespace std; #define MAXLEN 50 typedef struct { char ...
  • v_xchen_v
  • v_xchen_v
  • 2016-06-17 21:36:17
  • 1539

数据结构—栈和队列的相互模拟

1、两个栈模拟一个队列 栈是LILO,而队列是FIFO,所以可以: 入队,直接进A号栈; 出队,先判断B号栈是否有元素,有元素就直接弹出栈顶即队首,如果B号栈没有元素,则将A号栈的元素顺序弹出并进B号...
  • xwchao2014
  • xwchao2014
  • 2015-05-18 16:00:20
  • 341

用栈和队列实现虚拟停车场系统

学校的数据结构课程实验之一。 用到的数据结构:栈、队列   设停车场内只有一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序依次排列。   若车场内...
  • u012711841
  • u012711841
  • 2015-04-12 21:34:19
  • 600

数据结构与算法(C++版):表、栈和队列

前言本系列博客为学习数据结构与算法过程中的原创笔记,其中代码实现基于C++语言。STL中的向量和表在C++语言的库中包含有公共数据结构的实现,这就是众所周知的标准模版库(Standard Templa...
  • u013271326
  • u013271326
  • 2017-06-06 11:37:07
  • 272

停车场问题 用栈和队列模拟停车场

  • 2011年06月24日 20:34
  • 3KB
  • 下载

2088-数据结构实验之栈与队列十一:refresh的停车场

#include using namespace std;int main() { int n,t; while(cin >> n >> t) { stackS...
  • ywj_justdoit
  • ywj_justdoit
  • 2017-10-19 19:50:35
  • 118

停车场管理模拟

  • 2015年06月14日 23:27
  • 2.43MB
  • 下载

Java数组实现堆栈和队列

数组堆栈: public class Stack { private long[] stackArray; private int top; private int maxSize; p...
  • lingzhm
  • lingzhm
  • 2015-03-11 18:31:11
  • 1304

【栈和队列】栈和队列的基本应用(C++版)

【栈和队列】栈和队列的应用(C++版)
  • u012771236
  • u012771236
  • 2014-05-23 14:11:35
  • 2037
    个人资料
    持之以恒
    等级:
    访问量: 4566
    积分: 287
    排名: 27万+