精华内容
下载资源
问答
  • C++ 实现简单计算器

    2013-03-14 00:06:07
    c++ 利用数组做底层存储,实现入栈 出栈 空/满判断等基本操作,计算器实现加减乘除简单功能 ,支持中缀表达式
  • c++栈实现商品货架管理
  • C++栈基于类实现十进制转N进制; C ++ class-based stack transfer N-ary Decimal.
  • 数据结构课程设计之C++编写的迷宫问题路径求解程序,使用的是方法,即将路径上每一步存在中,迷宫文件格式见程序提示,压缩包内已经给出了三个测试用的迷宫地图可用来测试,支持分步显示查找路径过程功能,当给...
  • C++栈类模板

    2012-11-20 22:41:33
    C++栈类模板 template class Stack { public: Stack(void); void Push(const T &item;); //将元素item压入栈 T Pop(void); //将栈顶元素弹出栈 void ClearStack(void); T Peek(void)const; //访问栈顶元素 ...
  • 汉诺塔 c++

    2015-11-17 13:52:29
    1:学习的原理; 2:熟悉链表的构建与使用,利用链表实现; 3:利用求解汉诺塔问题; (里面都有文档的详细讲解)
  • 采用和队列数据结构及C++程序设计语言实现中缀表达式求值#数据结构实验#和队列应用#C++程序设计语言
  • C++ 的遍历

    2021-07-12 17:03:57
    思路: 将链表的指针push中,然后一个个将栈顶的元素pop出来,实现链表的反转。 void flip_in_stack(ListNode* head) { stack<ListNode*> flip_stack; // 将链表的指针压入堆栈 head = head->next; while...

    思路: 将链表的指针push栈中,然后一个个将栈顶的元素pop出来,实现链表的反转。

    void flip_in_stack(ListNode* head)
    {
    stack<ListNode*> flip_stack;
    // 将链表的指针压入堆栈
    head = head->next;
    while (head)
    {
    flip_stack.push(head);
    head = head->next;
    }
    while (!flip_stack.empty())
    {
    head = flip_stack.top();
    cout << head->data<< “<-”;
    flip_stack.pop();
    }
    }

    展开全文
  • C++栈的用法及栈的实现

    万次阅读 多人点赞 2017-04-11 15:19:43
    首先看一下原c++栈的方法的基本用法: push(): 向栈内压入一个成员; pop(): 从栈顶弹出一个成员; empty(): 如果栈为空返回true,否则返回false; top(): 返回栈顶,但不删除成员; size(): 返回栈内元素的大小; ...
    1. 首先看一下原c++栈的方法的基本用法:
      1. push(): 向栈内压入一个成员;
      2. pop(): 从栈顶弹出一个成员;
      3. empty(): 如果栈为空返回true,否则返回false;
      4. top(): 返回栈顶,但不删除成员;
      5. size(): 返回栈内元素的大小;
    2. 代码示例:
    #include<iostream>
    #include<stack>
    using namespace std;
    
    int main()
    {
        stack <int>stk;
        //入栈
        for(int i=0;i<50;i++){
            stk.push(i);
        }
        cout<<"栈的大小:"<<stk.size()<<endl;
        while(!stk.empty())
        {
            cout<<stk.top()<<endl;
            stk.pop();
        }
        cout<<"栈的大小:"<<stk.size()<<endl;
        return 0;
    }
    
    
    1. 接下来我们自己写栈,这时就需要用到c++中的模板类(template)
    #include<iostream>
    #include<stdlib.h>
    using namespace std;
    
    #define MAXSIZE 0xffff
    
    template<class type>
    class my_stack
    {
        int top;
        type* my_s;
        int maxsize;
    
    public:
        my_stack():top(-1),maxsize(MAXSIZE)
        {
            my_s=new type[maxsize];
            if(my_s==NULL)
            {
                cerr<<"动态存储分配失败!"<<endl;
                exit(1);
            }
        }
        my_stack(int size):top(-1),maxsize(size)
        {
            my_s=new type[maxsize];
            if(my_s==NULL)
            {
                cerr<<"动态存储分配失败!"<<endl;
                exit(1);
            }
        }
        ~my_stack()
        {
            delete[] my_s;
        }
        //是否为空
        bool Empty();
        //压栈
        void Push(type tp);
        //返回栈顶元素
        type Top();
        //出栈
        void Pop();
        //栈大小
        int Size();
    };
    
    template<class type>
    bool my_stack<type>::Empty()
    {
        if(top==-1){
            return true;
        }
        else
            return false;
    }
    
    template<class type>
    type my_stack<type>::Top()
    {
        if(top!=-1)
        {
            return my_s[top];
        }
        else
        {
            cout<<"栈空\n";
            exit(1);
        }
    }
    
    template<class type>
    void my_stack<type>::Push(type tp)
    {
        if(top+1<maxsize)
        {
            my_s[++top]=tp;
        }
        else
        {
            cout<<"栈满\n";
            exit(1);
        }
    }
    
    template<class type>
    void my_stack<type>::Pop()
    {
        if(top>=0)
        {
            top--;
        }
        else
        {
            cout<<"栈空\n";
            exit(1);
        }
    }
    
    template<class type>
    int my_stack<type>::Size()
    {
        return top+1;
    }
    
    
    1. 然后就可以在另一个cpp文件中使用它了(记得include):
    #include<iostream>
    #include "my_stack.cpp"
    
    using namespace std;
    
    int main()
    {
        my_stack<int> stk;
        for(int i=0;i<50;i++){
            stk.Push(i);
        }
        cout<<"栈的大小:"<<stk.Size()<<endl;
        while(!stk.Empty())
        {
            cout<<stk.Top()<<endl;
            stk.Pop();
        }
        cout<<"栈的大小:"<<sizeof(stk)<<endl;
        return 0;
    }
    
    1. 在编写代码的时候我突然很好奇,size()和sizeof输出的区别,然后我用我写的栈做了尝试:
    #include<iostream>
    #include<stack>
    #include "my_stack.cpp"
    
    using namespace std;
    
    int main()
    {
        my_stack<int> stk;
        stack<int> s;
        for(int i=0;i<20;i++){
            stk.Push(i);
            s.push(i);
        }
        cout<<"mysize()="<<stk.Size()<<"\nmysizeof="<<sizeof(stk)<<endl;
        cout<<"size()="<<s.size()<<"\nsizeof="<<sizeof(s)<<endl;
        return 0;
    }
    
    输出:
    mysize()=20
    mysizeof=12
    size()=20
    sizeof=40

    并且可以看到我写的栈类的变量只有三个整型(一个template型),刚好12个字节,由此可知c++提供的栈内不止我写的这么简单,光变量就占40个字节

    展开全文
  • C++栈和队列标准库函数

    万次阅读 多人点赞 2016-10-08 19:18:12
    C++栈和队列函数的库函数的使用方法, c++栈和队列的函数

    使用标准库的栈和队列时, 应包含先关头文件.
    在栈中应包含头文件: #include< stack >
    定义: stack< int > s;

    s.empty();         //如果栈为空则返回true, 否则返回false;
    s.size();          //返回栈中元素的个数
    s.top();           //返回栈顶元素, 但不删除该元素
    s.pop();           //弹出栈顶元素, 但不返回其值
    s.push();          //将元素压入栈顶

    队列

    包含头文件: #include< queue >
    定义: queue< int > q;

    q.empty();         //如果队列为空返回true, 否则返回false     
    q.size();          //返回队列中元素的个数
    q.front();         //返回队首元素但不删除该元素
    q.pop();           //弹出队首元素但不返回其值
    q.push();          //将元素压入队列
    q.back();          //返回队尾元素的值但不删除该元素
    展开全文
  • C++ (Stack)的基本操作

    万次阅读 多人点赞 2019-01-03 17:40:37
    一、的定义:  一种可以实现“先进后出(后进先出)”的存储结构  生活中的例子:玩具枪的子弹夹,后进来的子弹先射出。   二、分类:  静态:使用数组  动态:链表 三、算法:  出栈:push  ...

    一、栈的定义:

           一种可以实现“先进后出后进先出)”的存储结构

           生活中的例子:玩具枪的子弹夹,后进来的子弹先射出。

           

    二、分类:

                    静态栈:使用数组

                    动态栈:链表

    三、算法:

                   出栈:push

                    压栈:pop

                    栈是否为空:empty

                    栈的大小:size

                    访问栈顶:top

    四、应用:

         (1)函数中调用其它函数,其它函数运行完之后返回结果给上一级的函数。

         (2)中断

         (3)表达式求值

         (4)内存分配

         (5)缓冲处理

         (6)迷宫

    五、基本操作的实现程序:

    #include <iostream>
    using namespace std;
    
    // 结点结构体
    struct Node {
        int data;
        Node *next;
    };
    
    // 栈
    struct Stack {
        Node *pTop; // 顶部指针
        Node *pBottom; // 底部指针
    };
    
    void Init(Stack *pS); // 初始化
    void CreateStack(Stack *pS); // 建栈
    void Travers(Stack *pS); // 遍历栈
    void Push(Stack *pS, int val); // 压栈
    bool Pop(Stack *pS); // 出栈:把栈顶的结点删掉
    bool getTop(Stack *pS, int &val); // 获取栈顶元素:但不删除栈顶结点
    bool isEmpty(Stack *pS); // 判断栈是否为空
    int getSize(Stack *pS); // 获取栈的长度
    
    int main(int argc, const char * argv[]) {
        Stack s; // 声明对象,等价于 struct Stack s
        int val, choose, len; // val存储值,choose存储用户的选择
        bool finished = false;
        
        while(!finished) {
            cout << "1:初始化栈:" << endl;
            cout << "2:建栈(以-1结束输入):" << endl;
            cout << "3:遍历栈:" << endl;
            cout << "4:压栈:" << endl;
            cout << "5:出栈:" << endl;
            cout << "6:取栈顶的元素值:" << endl;
            cout << "7:栈是否为空:" << endl;
            cout << "8:获取栈的长度:" << endl;
            cout << "9:退出:" << endl;
            cout << "请输入你的选择[1-9]:" << endl;
            cin >> choose;
            switch(choose) {
                case 1:
                    Init(&s); // 初始化栈
                    break;
                case 2:
                    CreateStack(&s); // 建栈
                    break;
                case 3:
                    cout << "栈中的元素为:" << endl;
                    Travers(&s); // 遍历栈
                    break;
                case 4:
                    cout << "请输入要压入栈中的元素值:" << endl;
                    cin >> val;
                    Push(&s, val);
                    break;
                case 5:
                    if(Pop(&s)) // 出栈
                        cout << "出栈成功!" << endl;
                    else
                        cout << "出栈失败!" << endl;
                    break;
                case 6:
                    if(getTop(&s, val))
                        cout << "栈顶元素的值为:" << val << endl;
                    else
                        cout << "栈为空!" << endl;
                    break;
                case 7:
                    if(isEmpty(&s))
                        cout << "栈为空!" << endl;
                    else
                        cout << "栈不空" << endl;
                    break;
                case 8:
                    len = getSize(&s);
                    cout << "栈的长度为:" << len << endl;
                    break;
                case 9:
                    finished = true;
                    break;
                default:
                    cout << "输入选择错误,请重新输入!" << endl;
            }
        }
        return 0;
    }
    
    // 初始化
    void Init(Stack *pS) {
        pS->pTop = new Node();
        if(NULL == pS->pTop) {
            cerr << "动态内存分配失败!" << endl;
            exit(1);
        }
        pS->pBottom = pS->pTop; // 顶部指针和底部指针指向同一个位置
        pS->pTop->next = NULL; // pS->pBottom->next = NULL;
    }
    
    // 建栈
    void CreateStack(Stack *pS) {
        int val;
        cout << "请输入各个元素值:" << endl;
        
        while(cin >> val && val != -1)
            Push(pS, val);
    }
    
    // 压栈
    void Push(Stack *pS, int val) {
        Node *newNode = new Node(); // 新建结点
        if(NULL == newNode) {
            cerr << "动态内存分配失败!" << endl;
            exit(1);
        }
        newNode->data = val;
        newNode->next = pS->pTop;
        pS->pTop = newNode; // 顶端指针往上移
    }
    
    // 遍历栈
    void Travers(Stack *pS) {
        Node *p = pS->pTop;
        
        while(p != pS->pBottom) {
            cout << p->data << " ";
            p = p->next;
        }
        cout << endl;
    }
    
    // 判断栈是否为空:通过比较栈顶和栈尾指针是否相等,如相等,说明为空
    bool isEmpty(Stack *pS) {
        if(pS->pTop == pS->pBottom)
            return true;
        return false;
    }
    
    // 出栈:把栈顶的结点删掉
    bool Pop(Stack *pS) {
        if(isEmpty(pS))
            return false;
        Node *r = pS->pTop; // 暂存顶指针
        pS->pTop = r->next; // 栈顶指针往下移一个结点
        delete r; // 释放空间
        r = NULL; // 指向空
        return true;
    }
    
    // 获取栈顶元素:但不删除栈顶结点
    bool getTop(Stack *pS, int &val) {
        if(isEmpty(pS)) // 栈空,返回0
            return false;
        val = pS->pTop->data;
        return true; // 否则返回栈顶的元素值
    }
    
    // 获取栈的长度
    int getSize(Stack *pS) {
        int len = 0;
        Node *p = pS->pTop;
        while(p != pS->pBottom) {
            len++;
            p = p->next;
        }
        return len;
    }

     

    展开全文
  • 一个.CPP文件 通过匹配运算符,计算字符串类型的数学表达式,支持小数点。 运算符包括: + - * / ( ) ^
  • 本文实例为大家分享了C++栈(stack)的模板类实现代码,供大家参考,具体内容如下 1.基本概念  栈中的元素遵守“先进后出”的原则(LIFO,Last In First Out)  只能在栈顶进行插入和删除操作  压栈(或推入、进栈)即...
  • 利用和队列的特性设计一个算法,用于判断一个字符串是否为回文。 测试输入 abcdefg↵ 期待的输出 不是回文↵ 测试输入 abccba↵ 期待的输出 是回文↵ #include<iostream> using namespace std; class ...
  • c++栈实现简单计算器

    千次阅读 多人点赞 2017-10-10 13:50:16
    /* 实现计算器,主要思路就是设置一个符号和一个数字,在字符串首尾各加一个'#',然后扫描字符串, * 如果是数字进数字,如果是运算符号先判断符号优先级,若外符号优先级大于内符号优先级则进栈, *...
  • C++栈

    千次阅读 2019-01-17 16:06:15
    首先看一下原c++栈的方法的基本用法: push(): 向栈内压入一个成员; pop(): 从栈顶弹出一个成员; empty(): 如果栈为空返回true,否则返回false; top(): 返回栈顶,但不删除成员; size(): 返回栈内元素的大小 #...
  • C++栈实现表达式求值

    2019-10-31 20:56:20
    转载:https://blog.csdn.net/qq_40475529/article/details/79661475,方便以后查看(嘿嘿)
  • 利用C++栈和队列实现回文判断 可以自行输入
  • c/c++ 溢出、越界、泄漏

    千次阅读 2018-05-24 15:49:36
    我们规定内存的生长方向为向上,则的生长方向为向下。压栈的操作push=ESP-4,出栈的操作是pop=ESP+4.换句话说,堆栈中老的值,其内存地址,反而比新的值要大。请牢牢记住这一点,因为这是堆栈溢出的基本理论依据。...
  • c++ stack 用法

    万次阅读 多人点赞 2018-03-28 22:29:19
    c++ stlstack的头文件为: #include &lt;stack&gt; c++ stlstack的成员函数介绍操作 比较和分配堆栈empty() 堆栈为空则返回真pop() 移除栈顶元素push() 在栈顶增加元素size() 返回中...
  • c/c++栈的代码实现

    千次阅读 2018-11-13 22:23:14
    基本介绍 数组是一种神奇的工具,我们可以根据自己的需要来设计...我们往中从左到右插入元素,左端为底,右端为定 入栈 push(x); 在栈顶增加元素 出栈 pop(); 移除定元素 size(); 返回元素数目 top()...
  • 数据结构课程设计之C++编写的算术表达式求值,支持括号运算、小数运算、支持错误点报错(非法字符、括号不完整、缺运算数、算式不完整等)、支持中间过程显示(输入串、运算数、操作符);压缩包内为DevC++项目...
  • C++ 函数stack用法

    千次阅读 2019-05-25 11:36:58
    C++ Stack()提供了堆栈的全部功能,换句话说就是这里面已经实现了一个先进后出的数据结构。不需要我们再去重新定义各种函数,简化开发过程。 c++ stlstack的头文件书写格式为: #include<stack> 实例化...
  • 本程序通过C++实现数据结构中顺序,主要功能有压栈、弹、遍历、空间拓展等,具体功能函数如下: MStack(int tCapacity,bool& flag); ~MStack(); void Clear(); bool Empty() const; bool Push(ElemType&)...
  • C++ 基本操作

    千次阅读 2017-12-21 11:06:26
    一:目的 用C++实现的基本操作; 一:实现 1. 首先定义的结构和类,书写在stack.h中
  • 查了下是溢出,默认大小是1M连接器里 修改连接器的属性,调整大小,但是有什么问题没测过, 醉了。。 或者用new 再就是设计结构出现问题了, 根据情况考虑换成list,map,set 不是编译器傻吊!!! ...
  • 【C++】清空一个C++栈的快速方法

    千次阅读 2019-06-11 18:08:00
    来源:https://stackoverflow.com/questions/40201711/how-can-i-clear-a-stack-in-c-efficiently/40201744 传统方法,使用循环: #define elemType int void clearStack(stack<elemType>...
  • 主要为大家详细介绍了C++利用实现中缀表达式转后缀表达式,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 257,654
精华内容 103,061
关键字:

c++栈

c++ 订阅