3.栈与队列，c++模板类

最新推荐文章于 2022-09-26 10:52:42 发布
最新推荐文章于 2022-09-26 10:52:42 发布
阅读量166 收藏
点赞数
分类专栏： 随笔 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiguanlant/article/details/120015391
版权
本文探讨了栈（Stack）和队列（Queue）的数据结构实现，包括顺序表和链表版本，并展示了它们在括号匹配、表达式转换和图遍历中的实际应用。同时，深入解析了中缀表达式到后缀表达式的转换过程和后缀表达式的求值算法。
摘要由CSDN通过智能技术生成

栈：

Stack.h
#ifndef _STACK_H_
#define _STACK_H_

#define MaxSize 100

//顺序表实现
template<class T>
class SStack
{
public:
    SStack();
    ~SStack();

public:
    T pop();
    T top();
    int size();
    bool push(const T x);
    bool isEmpty();
    bool isFull();
    void clear();

private:
    T data[MaxSize];
    int Top;
};

//链表实现

template<class T>
class LSNode
{
public:
    LSNode():next_L(NULL){};
    LSNode(const T x, LSNode<T> *ptr = NULL)
    {
        data = x;
        next_L = ptr;
    }

public:
    T data;
    LSNode<T> *next_L;
};

template<class T>
class LStack : public LSNode<T>
{
public:
    LStack();
    ~LStack();

public:
    LSNode<T> *setPos();
    T pop();
    T top();
    int size();
    bool push(const T x);
    bool isEmpty();
    void clear();    

private:
    LSNode<T> *head, *Top;
};

#endif //_STACK_H_
Stack.cpp
#include "Stack.h"
#include <iostream>
using namespace std;

template<class T>
SStack<T>::SStack()
{
    Top = -1;
}

template<class T>
SStack<T>::~SStack()
{
    Top = -1;
}

template<class T>
T SStack<T>::pop()
{
    if(Top == -1)
    {
        cout << "Stack is empty return -1" << endl;
        return -1;
    }
    int idx = Top;
    Top --;
    return data[idx];
}

template<class T>
bool SStack<T>::push(const T x)
{
    if(Top == MaxSize-1)
    {
        cout << "Stack is full" << endl;
        return false;
    }
    data[++ Top] = x;
    return true;
}

template<class T>
bool SStack<T>::isEmpty()
{
    if(Top == -1)
        return true;
    return false;
}

template<class T>
void SStack<T>::clear()
{
    Top = -1;
}

template<class T>
T SStack<T>::top()
{
    return data[Top];
}

template<class T>
bool SStack<T>::isFull()
{
    if(Top == MaxSize-1)
        return true;
    return false;
}

template<class T>
int SStack<T>::size()
{
    return Top+1;
}

/*
                       .::::.
                     .::::::::.
                    :::::::::::  FUCK YOU
                ..:::::::::::'
              '::::::::::::'
                .::::::::::
           '::::::::::::::..
                ..::::::::::::.
              ``::::::::::::::::
               ::::``:::::::::'        .:::.
              ::::'   ':::::'       .::::::::.
            .::::'      ::::     .:::::::'::::.
           .:::'       :::::  .:::::::::' ':::::.
          .::'        :::::.:::::::::'      ':::::.
         .::'         ::::::::::::::'         ``::::.
     ...:::           ::::::::::::'              ``::.
    ````':.          ':::::::::'                  ::::..
                       '.:::::'                    ':'````..
*/

template<class T>
LSNode<T>* LStack<T>::setPos()
{
    LSNode<T> *p = head;
    if(head == Top)
    {
        return NULL;
    }
    while(p->next_L != Top)
    {
        p = p->next_L;
    }
    return p;
}

template<class T>
LStack<T>::LStack()
{
    head = new LSNode<T>(0, NULL);
    Top = head;
}


template<class T>
LStack<T>::~LStack()
{
    LSNode<T> *cur = head;
    while(cur != NULL)
    {
        LSNode<T> *del = cur;
        cur = cur->next_L;
        delete del;
    }
    head = NULL;
    Top = NULL;
}

template<class T>
void LStack<T>::clear()
{
    while(head != NULL)
    {
        LSNode<T> *p = head;
        head = head->next_L;
        delete p;
    }
    head = new LSNode<T>(0, NULL);
    Top = head;
}

template<class T>
T LStack<T>::pop()
{
    if(Top == head)
    {
        cout << "Stack is empty" << endl;
        return -1;
    }
    T x = Top->data;
    LSNode<T> *p = setPos();
    p->next_L = NULL;
    delete Top;
    Top = p;
    return x;
}

template<class T>
bool LStack<T>::push(const T x)
{
    LSNode<T> *p = new LSNode<T>(x, NULL);
    Top->next_L = p;
    Top = p;
    return true;
}

template<class T>
bool LStack<T>::isEmpty()
{
    if(Top == head)
        return true;
    return false;
}

template<class T>
T LStack<T>::top()
{
    if(Top == head)
        return -1;
    return Top->data;
}

template<class T>
int LStack<T>::size()
{
    LSNode<T> *p = head->next_L;
    int cnt = 0;
    while(p != NULL)
    {
        cnt ++;
        p = p->next_L;
    }
    return cnt;
}

队列

Dueue.h
#ifndef _QUEUE_H_
#define _QUEUE_H_
//待完善
#define MaxSize 100

//顺序表
template<class T>
class SQueue
{
public:
    SQueue();
    ~SQueue();

public:
    T front();
    T pop();
    int size();
    void clear();
    bool push(const T x);
    bool isEmpty();

private:
    T data[MaxSize];
    int head, tail;
};


//链式

template<class T>
class LNode
{
public:
    LNode():next_L(NULL){};
    LNode(const T x, LNode<T> *ptr = NULL)
    {
        data = x;
        next_L = ptr;
    }

public:
    T data;
    LNode<T> *next_L;
};

template<class T>
class LQueue : public LNode<T>
{
public:
    LQueue();
    ~LQueue();

public:
    T pop();
    T front();
    int size();
    void clear();
    bool push(const T x);
    bool isEmpty();


private:
    LNode<T> *head, *tail;
};


// 双端队列

template<class T>
class DueNode
{
public:
    DueNode():next_L(NULL){};
    DueNode(T d, DueNode<T> *ptr = NULL)
    {
        data = d;
        next_L = ptr;
    }

public:
    T data;
    DueNode<T> *next_L;
};

template<class T>
class Dueue
{
public:
    Dueue();
    ~Dueue();

public:
    
    T pop_back();
    T pop_front();
    T front();
    T back();
    int size();
    void clear();
    bool isEmpty();
    bool push_back(const T x);
    bool push_front(const T x);
    void Print();

private:
    DueNode<T> *head, *tail;
    DueNode<T> *setPos();
    int Size;
};

#endif //_QUEUE_H
Dueue.cpp
#include "Queue.h"
#include <iostream>
using namespace std;

template<class T>
SQueue<T>::SQueue()
{
    head = tail = 0;
}

template<class T>
SQueue<T>::~SQueue()
{
    head = tail = 0;
}

template<class T>
T SQueue<T>::front()
{
    if(head == tail)
    {
        cout << "queue is empty" << endl;
        return -1;
    }
    return data[head];
}

template<class T>
T SQueue<T>::pop()
{
    if(head == tail)
    {
        cout << "queue is empty" << endl;
        return -1;
    }
    int idx = head;
    head ++;
    return data[idx];
}

template<class T>
bool SQueue<T>::push(const T x)
{
    if(tail == MaxSize)
    {
        cout << "queue is full" << endl;
        return false;
    }
    data[tail ++] = x;
    return true;
}

template<class T>
bool SQueue<T>::isEmpty()
{
    if(head == tail)
        return true;
    return false;
}

template<class T>
void SQueue<T>::clear()
{
    head = tail = 0;
}

template<class T>
int SQueue<T>::size()
{
    return tail-head;
}

/*
                       .::::.
                     .::::::::.
                    :::::::::::  FUCK YOU
                ..:::::::::::'
              '::::::::::::'
                .::::::::::
           '::::::::::::::..
                ..::::::::::::.
              ``::::::::::::::::
               ::::``:::::::::'        .:::.
              ::::'   ':::::'       .::::::::.
            .::::'      ::::     .:::::::'::::.
           .:::'       :::::  .:::::::::' ':::::.
          .::'        :::::.:::::::::'      ':::::.
         .::'         ::::::::::::::'         ``::::.
     ...:::           ::::::::::::'              ``::.
    ````':.          ':::::::::'                  ::::..
                       '.:::::'                    ':'````..
*/

template<class T>
LQueue<T>::LQueue()
{
    head = new LNode<T>(0, NULL);
    tail = head;
}


template<class T>
LQueue<T>::~LQueue()
{
    LNode<T> *cur = head;
    while(cur != NULL)
    {
        LNode<T> *del = cur;
        cur = cur->next_L;
        delete del;
    }
    head = NULL;
    tail = NULL;
}

template<class T>
T LQueue<T>::pop()
{
    if(head == tail || head->next_L == NULL)
    {
        cout << "queue is empty" << endl;
        return -1;
    }
    LNode<T> *p = head->next_L;
    head->next_L = p->next_L;
    T x = p->data;
    if(p == tail)
        tail = head;
    delete p;
    return x;
}

template<class T>
T LQueue<T>::front()
{
    if(head == tail || head->next_L == NULL)
    {
        cout << "queue is empty" << endl;
        return -1;
    }
    return head->next_L->data;
}

template<class T>
int LQueue<T>::size()
{
    LNode<T> *p = head->next_L;
    int cnt = 0;
    while(p != NULL)
    {
        cnt ++;
        p = p->next_L;
    }
    return cnt;
}

template<class T>
void LQueue<T>::clear()
{
    LNode<T> *cur = head->next_L;
    while(cur != NULL)
    {
        LNode<T> *del = cur;
        cur = cur->next_L;
        delete del;
    }
    head->next_L = NULL;
    tail = head;
}

template<class T>
bool LQueue<T>::push(const T x)
{
    LNode<T> *p = new LNode<T>(x, NULL);
    tail->next_L = p;
    tail = p;
    return true;
}

template<class T>
bool LQueue<T>::isEmpty()
{
    if(head == tail)
        return true;
    return false;
}

/*
                           _ooOoo_
                          o8888888o
                          88" . "88
                          (| -_- |)
                           O\ = /O
                       ____/`---'\____
                     .   ' \\| |// `.
                      / \\||| : |||// \
                    / _||||| -:- |||||- \
                      | | \\\ - /// | |
                    | \_| ''\---/'' | |
                     \ .-\__ `-` ___/-. /
                  ___`. .' /--.--\ `. . __
               ."" '< `.___\_<|>_/___.' >'"".
              | | : `- \`.;`\ _ /`;.`/ - ` : | |
                \ \ `-. \_ __\ /__ _/ .-` / /
        ======`-.____`-.___\_____/___.-`____.-'======
                           `=---='

        .............................................
                 佛祖镇楼                 BUG辟易
         佛曰:
                 写字楼里写字间，写字间里程序员；
                 程序人员写程序，又拿程序换酒钱。
                 酒醒只在网上坐，酒醉还来网下眠；
                 酒醉酒醒日复日，网上网下年复年。
                 但愿老死电脑间，不愿鞠躬老板前；
                 奔驰宝马贵者趣，公交自行程序员。
                 别人笑我忒疯癫，我笑自己命太贱；
                 不见满街漂亮妹，哪个归得程序员？
*/

template<class T>
Dueue<T>::Dueue()
{
    head = new DueNode<T>(0, NULL);
    tail = head;
    Size = 0;
}

template<class T>
Dueue<T>::~Dueue()
{
    DueNode<T> *cur = head;
    while(cur != NULL)
    {
        DueNode<T> *del = cur;
        cur = cur->next_L;
        delete del;
    }
    head = tail = NULL;
    Size = 0;
}

template<class T>
int Dueue<T>::size()
{
    return Size;
}

template<class T>
bool Dueue<T>::isEmpty()
{
    if(head == tail)
        return true;
    return false;
}

template<class T>
void Dueue<T>::clear()
{
    DueNode<T> *p = head->next_L;
    while(p != NULL)
    {
        DueNode<T> *del = p;
        p = p->next_L;
        delete del;
    }
    head->next_L = NULL;
    Size = 0;
    tail = head;
}

template<class T>
T Dueue<T>::back()
{
    return tail->data;
}

template<class T>
T Dueue<T>::front()
{
    DueNode<T> *p = head->next_L;
    return p->data;
}

template<class T>
DueNode<T> *Dueue<T>::setPos()
{
    DueNode<T> *p;
    p = head;
    while(p != NULL && p->next_L != tail)
    {
        p = p->next_L;
    }
    return p;
}

template<class T>
T Dueue<T>::pop_back()
{
    DueNode<T> *p = setPos();
    const T x = tail->data;
    p->next_L = NULL;
    delete tail;
    tail = p;
    Size --;
    return x;
}

template<class T>
T Dueue<T>::pop_front()
{
    DueNode<T> *p = head->next_L;
    const T x = p->data;
    head->next_L = p->next_L;
    if(p == tail)
        tail = head;
    delete p;
    Size --;
    return x;
}

template<class T>
bool Dueue<T>::push_back(const T x)
{
    DueNode<T> *p = new DueNode<T>(x, NULL);
    tail->next_L = p;
    tail = p;
    Size ++;
    return true;
}

template<class T>
bool Dueue<T>::push_front(const T x)
{
    DueNode<T> *p = new DueNode<T>(x, NULL);
    DueNode<T> *q = head->next_L;
    head->next_L = p;
    p->next_L = q;
    Size ++;
    return true;
}

template<class T>
void Dueue<T>::Print()
{
    DueNode<T> *p = head->next_L;
    while(p != NULL)
    {
        cout << p->data << " ";
        p = p->next_L;
    }
    cout << endl;
}

栈的应用

#include <iostream>
#include "Stack.h"
#include "Stack.cpp"
#include "Queue.h"
#include "Queue.cpp"
using namespace std;


//栈的括号匹配
void func1(const string a)
{
    LStack<char> s;
    for(int i = 0; i < a.length(); ++ i)
    {
        if(a[i] == '(' || a[i] == '{' || a[i] == '[')
        {
            s.push(a[i]);
        } 
        else
        {
            char e = s.pop();
            if(e == '(' && a[i] != ')')
            {
                cout << "匹配失败" << endl;
                break;
            }
            else if(e == '[' && a[i] != ']')
            {
                cout << "匹配失败" << endl;
                break;
            }
            else if(e == '{' && a[i] != '}')
            {
                cout << "匹配失败" << endl;
                break;
            }
        }
    }
    if(s.isEmpty())
    {
        cout << "匹配成功" << endl;
    }
    else 
    {
        cout << "匹配失败" << endl;
    }
}

//判断是否为操作符
bool isOperator(char ch)
{
    if(ch == '+' || ch == '-' || ch == '*' || ch == '/')
        return true;
    return false;
}
//获得优先级
int getPriority(char ch)
{
    int level = 0;

    switch(ch)
    {
        case '(':
            level = 1;
            break;
        case '+':
        case '-':
            level = 2;
            break;
        case '*':
        case '/':
            level = 3;
            break;
        default:
            break;
    }
    return level;
}

//栈中缀表达式转后缀表达式
void func2()
{
    string a, b = "";
    cout << "请输入一个中缀表达式: ";
    cin >> a;
    LStack<char> s;
    int len = a.length();
    int i = 0;
    while(i < len)
    {
        if(a[i] >= '0' && a[i] <= '9')
        {
            do
            {
                b += a[i];
                i ++;
            } while (a[i] >= '0' && a[i] <= '9');
            b += ' ';
        }
        else if(a[i] == '(')
        {
            s.push(a[i]);
            i ++;
        }
        else if(isOperator(a[i]))
        {
            if(s.isEmpty())
            {
                s.push(a[i]);
                i ++;
            }
            else
            {
                while(!s.isEmpty())
                {
                    char c = s.top();
                    if(getPriority(a[i]) <= getPriority(c))
                    {
                        b += c;
                        b += ' ';
                        s.pop();
                    }
                    else 
                        break;
                }
                s.push(a[i]);
                i ++;
            }
        }
        else if(a[i] == ')')
        {
            while(s.top() != '(')
            {
                b += s.top();
                b += ' ';
                s.pop();
            }
            s.pop();
            i ++;
        }
    }
    while(!s.isEmpty())
    {
        b += s.top();
        b += ' ';
        s.pop();
    }
    cout << b << endl;
}


//后缀表达式求值
void func3()
{
    string a;
    cout << "请输入一个后缀表达式: ";
    getline(cin, a);
    LStack<int> s;
    int i = 0, len = a.length();
    while(i < len)
    {
        if(a[i] >= '0' && a[i] <= '9')
        {
            int now = 0;
            while(a[i] >= '0' && a[i] <= '9')
            {
                now = now*10+(a[i]-'0');
                i ++;
            }
            s.push(now);
        }
        else if(a[i] == ' ')
        {
            i ++;
            continue;
        }
        else
        {
            int num1 = s.pop();
            int num2 = s.pop();
            if(a[i] == '+')
            {
                s.push(num1+num2);
            }
            if(a[i] == '/')
            {
                s.push(num1/num2);
            }
            if(a[i] == '*')
            {
                s.push(num1*num2);
            }
            if(a[i] == '-')
            {
                s.push(num1-num2);
            }
        }
        i ++;
    }
    cout << s.top() << endl;
}


int main()
{
    func3();
    return 0;
}

队列的应用

图的层次遍历，深度优先搜索

xiguanlant
关注
专栏目录
C++作业模板实现栈和队列
m0_53451387的博客
04-24 560
【代码】C++作业模板实现栈和队列。
c++ 类模板 用栈实现队列
Li_zhonglei的博客
08-05 904
c++语言可以利用STL库中定义的栈类实现队列的操作。 包括入队列、出队列操作。 下面就是用两个栈实现队列的上述操作。其中涉及到类模板的知识，不清楚的可以去其它地方进行查询。 #include #include using namespace std; template class CQueue { public: //CQueue(void); //~CQueue(v
c/c++简单实现栈与队列模板
为啥不吃肉捏 的博客
04-30 268
完整代码，直接copy可测试效果。 1.栈 栈，又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 template <class T> class Stack { T *m_space; //栈空间 int m_si.
C++使用模板实现栈(Stack)和队列(Queue)的数据结构算法
weixin_42844163的博客
02-02 802
一、 模板介绍 1.函数模板的原理 (a )每一次使用一个新类型去调用模板，编译器内部都按照该类型生成新类型的函数 (b )这个生成新的具体类型函数的过程叫做模板的实例化 (c )每有一个新的模板实例化，d等于内部新增加了一个函数，编译尺寸会变大 2.类模板 (a )类模板的实例化过程和函数模板一样，也是根据调用类型实例化生成新的一个类 (b )类成员函数外编写需要重新指定:template &l...
栈和队列的模板形式 - C++实现
CC_且听风吟丶的博客
06-30 265
都用的头文件形式 栈的模板形式 #ifndef _MYSTACK_H #define _MYSTACK_H // 栈 template <typename T> struct Node { T data; struct Node<T> * next; }; template <typename T> struct Stack { Node&l...
C++利用链表模板类实现简易队列
08-26
C++利用链表模板类实现简易队列 本文主要为大家详细介绍了C++利用链表模板类实现一个简易队列，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 知识点一：链表模板类 在C++中，链表是一种常用的数据结构，...
循环队列 C++不同策略模板实现
12-11
5. **模板类的定义**：在C++中，定义一个循环队列的模板类可能包括如下部分： - 类模板参数：指定存储的数据类型。 - 成员变量：存储数组、队头和队尾的索引，以及队满处理标志或元素计数器。 - 成员函数：包括...
C++ 循环队列和链式队列的实现 数据结构 类模板
02-04
1. Queue.hpp是队列的基类，只定义基本操作，具体实现在另外两个hpp文件中 2. seqQueue.hpp是循环队列的实现 3. linkQueue.hpp是链式队列的实现 4. test.cpp是简单的测试文件，main函数在这里面
C语言实现栈与队列_C++
09-21
在C++中，类可以更好地实现数据封装和抽象，同时还可以利用模板（Template）来创建泛型栈和队列，这样它们就可以处理不同类型的数据。 总的来说，这个项目旨在通过C语言基础和C++的面向对象特性，提供一个简单但...
C++栈与队列的实现
m0_52759155的博客
04-11 99
C++栈与队列的实现一.头文件及定义栈的相关函数栈操作队列相关函数队列操作 一.头文件及定义 #include <stack> //栈的头文件 #include<queue >//队列头文件 stack<int> s;//定义了int类型的栈 queue<int>q;//定义了int类型的队列 栈的相关函数 s.empty() 如果栈为空返回true，否则返回false s.size() 返回栈
ts-stack：开源Typescript项目的入门仓库
02-17
添加包裹 新服务和应用程序应添加到它们各自的包路径中，即packages/backend/和packages/frontend 。 要使用Typescript进行编译，他们需要将其路径添加到tsconfig.json根tsconfig.json ，例如， references: [{ "path": "packages/backend/new-service" }] 。 由于使用配置，因此开发人员依赖项在项目之间共享并提升到工作区根目录。 如果出现问题，则可以使用针对特定软件包的nohoist配置-。
C++数组实现队列、堆栈、模板类
MiXiang 的专栏
03-01 1321
前面发现老师要求我们写一个堆栈、队列，但是我发现每一次都要修改数据类型，而且我在网上也没找到模板类，所以我就自己看了看模板类的知识，自己用数组写了一个，貌似使用起来没有什么问题。 1. 循环队列 template class MyQueue { private: int front; int rear; int size; int maxSize; T *ele; public:
栈和队列（模板）
灯火阑珊_
01-13 161
数组模拟栈 #include <iostream> using namespace std; const int N = 100010; int stk[N],tt; //插入 stk[ ++ tt] = x; //弹出 tt -- ; //判断栈是否为空 if(tt > 0) not empty; else is empty; //栈顶 stk[tt]; 数组模拟队列 #include <iostream> using namespace s..
数据结构学习（栈与队列：一（创建Stack模板类））
weixin_43723259的博客
07-26 248
栈 栈的模板类 栈是一种存放数据的特殊容器，其中元素按线性的逻辑顺序排列。栈也支持元素的插入和删除操作，不同的是，其操作的范围仅限于栈的某一特定端，禁止操作的另一端成为盲端。 就像把椅子叠成一摞一样，新的椅子只能放到最顶端；反过来，只有最顶端的椅子才能被移走。就像栈一样，可操作的一段被称之为栈顶， 不可操作的一端称之为栈底。 由以上栈操作的叙述不难看出，栈中元素接受操作的次序必须遵循所谓的后进先出（Last-in-first-out，LIFO) 的规律。 栈可以视作序列的特例，，故可以将栈作为向量类的派生类
计算机中的栈的模板,面向对象编程之模板编写栈队列
weixin_36149065的博客
07-25 243
面向对象编程之模板编写栈队列作业笔记 throw_try_catch nullptr_0_NULL delete_c++操作文件：tryQueue.cpp定义栈[1](英语：stack)又称为栈或堆叠，是计算机科学中一种特殊的串列形式的抽象资料型别，其特殊之处在于只能允许在链接串列或阵列的一端(称为堆叠顶端指标，英语：top)进行加入数据(英语：push)和输出数据(英语：pop)的运算。另外栈也...
数据结构之栈模板
m0_66029639的博客
02-20 341
栈 先进后出 队列 队列是一种常用的数据结构，可以将队列看做是一种特殊的线性表，遵循先进先出原则。分分为队列queue和双向队列deque。 队列queue 使用LinkedList实现queue。操作的方法如下： 抛出异常 返回值 插入 add(e) offer(e) 移除 remove() poll() 检查 element() peek() boolean add(E e);将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返...
数据结构-使用ts创建一个栈
poppy995的博客
06-21 299
`tips:使用数组的时候，大部分方法的时间复杂度一般是O(n)。O(n)的意思是，我们需要迭代整个数组直到找到要找的那个元素，再最坏的情况下需要迭代数组的所有位置，n代表的数据的长度。`
Stack类-Template泛型编程实现
Wwc_code的博客
06-14 192
实现步骤 1.编写stack栈类，实现stack栈的各个功能（push,pop,getsize…） 2.输入一个字符串，将字符串逆序输出 3.将stack类模板化 Stack.h #include<iostream> using namespace std; template<typename T> class Stack { private: size_t size{ 0 }; T elements[100]; public: Stack(); bool empty();
数据结构-栈（TS based）
Aiyiosis的博客
09-26 275
栈是重要的数据结构之一，在JS的数组之中原生就支持了push和pop操作，因此直接用数组实际上就可以满足栈、队列这些数据结构的需求。而使用TS的面向对象特性，我们可以将栈再次进行封装，并且合理地运用软件设计模式来完善数据结构，一方面可以起到练习的目的，另一方面可以提高代码的可读性和可复用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值