011 模板栈和队列

/*
目录:
一: 栈模板
    1 类内编写
    2 类外编写
二: 队列
    1 类内编写
    2 类外编写
*/    

一: 栈模板
  1 类内编写

// Stack.h
#pragma once
#include <iostream>

template<typename DATA>
class CStack
{
public:
    CStack() :m_nTop(-1)
    {

    }
    bool isFull()
    {
        if (m_nTop + 1 >= COUNT)
        {
            return true;
        }
        return false;
    }

    bool isEmpty()
    {
        if (-1 == m_nTop)
        {
            return true;
        }
        return false;
    }

    bool push(const DATA &data)
    {
        if (true != isFull())
        {
            ++m_nTop;
            m_data[m_nTop] = data;
            return true;
        }

        return false;
    }

    bool pop(DATA &data)
    {
        if (true != isEmpty())
        {
            data = m_data[m_nTop];
            --m_nTop;
            return true;
        }

        return false;
    }

private:

    enum {COUNT = 5};
    DATA m_data[COUNT];
    int m_nTop;
};
#include "stdafx.h"
#include "Stack.h"

using namespace std;

int main(int argc, char *argv[], char **envp)
{
    CStack<int> st;

    int nLoop = 0;
    while (nLoop < 10)
    {
        st.push(nLoop + 1);
        ++nLoop;
    }

    nLoop = 0;
    while (nLoop < 10)
    {
        int data;
        if (true == st.pop(data))
        {
            cout << data << endl;
        }

        ++nLoop;
    }
    return 0;
}

  2 类外编写

// Stack.h
#pragma once
#include <iostream>

template<typename DATA>
class CStack
{
public:
    CStack(int nCount = 10);

    bool isFull();
    bool isEmpty();

    bool push(const DATA &data);
    bool pop(DATA &data);

private:
    DATA *m_pData;
    int m_nCount;
    int m_nTop;
};

template<typename DATA>
CStack<DATA>::CStack(int nCount): m_nTop(-1)
{
    m_pData = new DATA[nCount];
    m_nCount = nCount;
}

template<typename DATA>
bool CStack<DATA>::isFull()
{
    if (m_nTop + 1 >= m_nCount)
    {
        return true;
    }
    return false;
}

template<typename DATA>
bool CStack<DATA>::isEmpty()
{
    if (-1 == m_nTop)
    {
        return true;
    }
    return false;
}

template<typename DATA>
bool CStack<DATA>::push(const DATA &data)
{
    if (true != isFull())
    {
        ++m_nTop;
        m_pData[m_nTop] = data;
        return true;
    }

    return false;
}

template<typename DATA>
bool CStack<DATA>::pop(DATA &data)
{
    if (true != isEmpty())
    {
        data = m_pData[m_nTop];
        --m_nTop;
        return true;
    }

    return false;
}

二: 队列
  1 类内编写

#pragma once
typedef int DATA;

class CQueue
{
public:
    CQueue(int nCount = 6)
    {
        m_pData = new DATA[nCount];
        m_nHead = m_nTail = 0;
        m_nCount = nCount;
    }
    ~CQueue()
    {
        delete[] m_pData;
    }

    bool isFull()
    {
        if (m_nHead == (m_nTail + 1) % m_nCount)
        {
            return true;
        }
        return false;
    }

    bool isEmpty()
    {
        if (m_nTail == m_nHead)
        {
            return true;
        }
        return false;
    }

    bool push(const DATA &data)
    {
        if (true == isFull())
        {
            return false;
        }

        m_pData[m_nTail] = data;
        m_nTail = ++m_nTail % m_nCount;
        return true;
    }

    bool pop(DATA &data)
    {
        if (true == isEmpty())
        {
            return false;
        }

        data = m_pData[m_nHead];
        m_nHead = ++m_nHead % m_nCount;
        return true;
    }

private:
    DATA *m_pData;
    int m_nCount;
    int m_nHead, m_nTail;
};
#include "stdafx.h"
#include "Queue.h"
#include <iostream>

using namespace std;

int main(int argc, char *argv[], char **envp)
{
    CQueue q;

    int nLoop = 0;
    while (nLoop < 10)
    {
        q.push(nLoop);
        ++nLoop;
    }

    int d;
    q.pop(d);
    cout << d << endl;
    q.pop(d);
    cout << d << endl;

    nLoop = 0;
    while (nLoop < 5)
    {
        q.push(nLoop + 1);
        ++nLoop;
    }

    while (true == q.pop(d))
    {
        cout << d << endl;
    }

    return 0;
}

  2 类外编写

#pragma once

template<typename DATA>

class CQueue
{
public:
    CQueue(int nCount = 6);
    ~CQueue();

    bool isFull();
    bool isEmpty();

    bool push(const DATA &data);
    bool pop(DATA &data);

private:
    DATA *m_pData;
    int m_nCount;
    int m_nHead, m_nTail;
};

template<typename DATA>
CQueue<DATA>::CQueue(int nCount)
{
    m_pData = new DATA[nCount];
    m_nHead = m_nTail = 0;
    m_nCount = nCount;
}

template<typename DATA>
CQueue<DATA>::~CQueue()
{
    delete[] m_pData;
}

template<typename DATA>
bool CQueue<DATA>::isFull()
{
    if (m_nHead == (m_nTail + 1) % m_nCount)
    {
        return true;
    }
    return false;
}

template<typename DATA>
bool CQueue<DATA>::isEmpty()
{
    if (m_nTail == m_nHead)
    {
        return true;
    }
    return false;
}

template<typename DATA>
bool CQueue<DATA>::push(const DATA &data)
{
    if (true == isFull())
    {
        return false;
    }

    m_pData[m_nTail] = data;
    m_nTail = ++m_nTail % m_nCount;
    return true;
}

template<typename DATA>
bool CQueue<DATA>::pop(DATA &data)
{
    if (true == isEmpty())
    {
        return false;
    }

    data = m_pData[m_nHead];
    m_nHead = ++m_nHead % m_nCount;
    return true;
}

原文地址:https://www.cnblogs.com/huafan/p/11632759.html

时间: 2024-10-24 14:11:47

011 模板栈和队列的相关文章

C++标准模板库STL算法与自适应容器(栈和队列)

参考<21天学通C++>第23与第24章节,对STL算法与自适应容器进行介绍. 实际上在前面的STL顺序容器.关联容器进行介绍时或多或少引用到了一些STL算法中的模板函数.而自适应容器是在顺序容器的基础上按照stack.queue的性质进行定制实现的.所以,本篇博文将言简意赅地总结出需要掌握的纲要. 一.STL算法 查找.搜索.删除.计数.排序等都是一些通用算法,STL通过模板函数提供了这些算法,可通过迭代器对容器进行操作.需要包含<algorithm>头文件. 1. find,f

数据结构与算法系列研究二——栈和队列

栈和队列的相关问题分析 一.栈和队列定义 栈和队列是两种重要的数据结构.从结构特性角度看,栈和队列也是线性表,其特殊性在于它们的基本操作是线性表的子集,是操作受限的线性表,可称为限定性的数据结构:从数据类型角度看,其操作规则与线性表大不相同,是完全不同于线性表的抽象数据类型.                    图1 栈的结构                                                 图2 队列的结构   1.1.栈是限定在表的一端进行插入和删除操作的线性

剑指offer-第二章数据结构(数组,字符串,链表,树,栈与队列)及例题

一.数组(最简单的数据结构) 定义:占据一块连续内存并按照顺序存储数据.创建时先指定大小,分配内存. 优点:时间效率高.实现简单的hash(下标为key,对应的数据为value) 缺点:空间效率差.如果我们只在数组中存一个数字,也先分配所有的内存. 扩展:动态数组(解决空间效率差),手段:扩容后,复制内容到新的数组,释放之前的内存.时间性能变差,因此,要尽量减少改变数组容量的次数. 数组与指针:声明一个数组时,数组名字也是一个指针,指向数组的第一个元素. 例题:在一个二维数组中,每一行都按照从左

数据结构实验三《栈和队列》

<数据结构>实验三 栈和队列 一.实验目的 巩固栈和队列数据结构,学会运用栈和队列. 1.回顾栈和队列的逻辑结构和受限操作特点,栈和队列的物理存储结构和常见操作. 2.学习运用栈和队列的知识来解决实际问题. 3.进一步巩固程序调试方法. 4.进一步巩固模板程序设计. 二.实验时间 准备时间为第5周到第6周,具体集中实验时间为6周第2次课.2个学时. 三.实验内容 1.自己选择顺序或链式存储结构,定义一个空栈类,并定义入栈.出栈.取栈元素基本操作.然后在主程序中对给定的N个数据进行验证,输出各个

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

栈和队列的应用非常之广,只要问题满足后进先出和先进先出原则,均可使用栈和队列作为其数据结构. (注意:在下面的代码中,我直接使用C++标准库提供的模板stack和queue,如果您用C语言,则要用前面介绍的方法自己实现stack和queue) 栈的应用 数制转换: 将一个非负的十进制整数N转换为另一个等价的基为B的B进制数的问题,很容易通过"除B取余法"来解决. [例]将十进制数13转化为二进制数. 解答:按除2取余法,得到的余数依次是1.0.1.1,则十进制数转化为二进制数为1101

7.14 单调栈 单调队列 +dp优化

单调栈和单调队列的定义具体看ppt了 模板: 单调队列 head =1; tail = 0; rep( i ,1 ,n ){ while( head <= tail && a[i] < dq[tail].first)tail--; while( head <= tail && dq[head].second < i-k+1) head++; dq[ ++tail ]={a[i] ,i}; 例题:https://vjudge.net/contest/3

快速记忆数组栈和队列函数push()和shift()

在js中,对数组的操作是比较常见的,有时候,我们需要模拟栈和队列的特性才能实现需求,今天来给大家用通俗易懂.简洁明了的几行文字,来告诉大家栈和队列的几个函数,如何快速记住. 首先,概念还是要知道的: 栈(stack)又名堆栈,它是一种运算受限的线性表.其限制是仅允许在表的一端进行插入和删除运算.这一端被称为栈顶,相对地,把另一端称为栈底.向一个栈插入新元素又称作进栈.入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素:从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻

3-3-行编辑程序-栈和队列-第3章-《数据结构》课本源码-严蔚敏吴伟民版

课本源码部分 第3章  栈和队列 - 行编辑程序 ——<数据结构>-严蔚敏.吴伟民版        源码使用说明  链接??? <数据结构-C语言版>(严蔚敏,吴伟民版)课本源码+习题集解析使用说明        课本源码合辑  链接??? <数据结构>课本源码合辑        习题集全解析  链接??? <数据结构题集>习题解析合辑        本源码引入的文件  链接? SequenceStack.c        相关测试数据下载  链接? 无数据

用栈实现队列的效果

用两个栈实现队列的效果,可以入栈,出栈,判空等... 实现的栈基本功能 lstack.h #ifndef _LSTACK_H #define _LSTACK_H #include <stdexcept> using namespace std; // 基于链式表的堆栈 class Stack { public: // 构造过程中初始化为空堆栈 Stack (void) : m_top (NULL) {} // 析构过程中销毁剩余的节点 ~Stack (void) { for (Node* ne