栈的C++实现及其应用

最新推荐文章于 2024-06-26 13:41:53 发布
最新推荐文章于 2024-06-26 13:41:53 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 栈 C++实现 后缀表达式 两个栈实现一个队列 顺序栈的实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ajay666/article/details/75528523
版权

栈是一种先进后出的数据结构，是一种功能受限的线性表。因为这世间存在这后进先出的计算顺序，为简化计算的过程，栈得以应用。好比装水的桶，好比装子弹的弹夹。

栈的C++实现

本文主要是编程实现栈，使用的是顺序储存结构（动态数组）来实现栈，需要注意的是当内存空间不够用，即栈满的时候，应该将重新开辟新的空间（大小为源空间大小+STACK_INCREMENT），然后将数据复制到新空间，在重新释放旧空间。
下面给出头文件定义(Stack.h)：

#define STACK_INIT_SIZE 100 ///the size of stack after initialized
#define STACK_INCREMENT 10  ///the increment of stack growth
class Stack{
private:
    int *base;///using array to store element
    int top;///use index(index of base) to find the top element of stack
    int stacksize;
    ///will be called when push a element to a full stack(top = stacksize)
    bool ReallocateMemory();
public:
    ///apply for memory and form a empty stack
    Stack();
    ///destroy the stack s and s won't exist anymore
    void DestroyStack();
    ///clear the stack s and s become a empty stack
    void ClearStack();
    ///get top element of stack while s is not empty otherwise return false
    bool GetTop(int &e);
    ///insert a element to the stack
    bool Push(int e);
    ///remove the top element and return it
    bool Pop(int &e);
    ///get stack size
    int GetSize();
};

不难看出，栈的函数比较少，可以很容易写出其函数定义（Stack.cpp）：

#include "Stack.h"
///apply for memory and form a empty stack
Stack::Stack(){
    base = new int[STACK_INIT_SIZE];
    top = 0;
    stacksize = STACK_INIT_SIZE;
}
///will be called when push a element to a full stack(top = stacksize)
bool Stack::ReallocateMemory(){
    int * tmp = new int[stacksize+STACK_INCREMENT];
    for(int i = 0; i < top; ++i){
        tmp[i] = base[i];
    }
    delete [] base;
    base = tmp;
    stacksize +=STACK_INCREMENT;
    if(base!=nullptr)
        return true;
    return false;
}
///destroy the stack s and s won't exist anymore
void Stack::DestroyStack()
{
    delete [] base;
    base = nullptr;
    top = 0;
    stacksize = 0;
}
///clear the stack s and s become a empty stack
inline void Stack::ClearStack(){
    top = 0;
}
///get top element of stack while s is not empty otherwise return false
bool Stack::GetTop(int &e){
    if(top==0)
        return false;
    e=base[top-1];
    return true;
}
///insert a element to the stack
bool Stack::Push(int e){
    bool flag;
    if(top==stacksize)
        flag = ReallocateMemory();
    base[top++]=e;
    return flag;
}
///remove the top element and return it
bool Stack::Pop(int &e){
    if(top==0)
        return false;
    e = base[--top];
    return true;
}
///get stack size
inline int Stack::GetSize(){
    return top;
}

这里top是动态数组的下标，指向栈顶元素的下一个位置，当top=0时，表示栈空，当top=stacksize时，表示栈满。
测试
下面给出测试代码(main.cpp)：

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

int main()
{
    Stack s;
    int e;
    for(int i = 0;i<110;++i)
        s.Push(i);
    for(int i = 0;i<110;++i)
    {
        if(s.Pop(e))
            cout<<e<<' ';
    }
    cout<<endl;
    return 0;
}

上述代码的思路是依次向栈压入0/1/2/3/4…109，那么输出应该是109/108…0。
测试结果：
这里写图片描述

栈的应用

1、表达式求值
（1）我们知道，对于中缀表达式而言，不好判断计算顺序，于是波兰学者提出了后缀表达式的概念，而后缀表达式非常适合程序的处理。如果不清楚这个算法的话，可以参考博文：后缀表达式。
（2）对算法有所了解以后，我们可以发现，要想计算表达式的值，需要先将中缀表达式转换成后缀表达式（步骤一），然后利用后缀表达式进行求值（步骤二）；而将中缀表达式转换成后缀表达式的关键在于算符优先表的构建；上述的两个过程都涉及到栈的应用；
这里写图片描述
（3）步骤一编程实现：

///算符优先表，1表示>,0表示=,-1表示<,2表示不存在优先关系
int opTable[7][7]={
1,1,-1,-1,-1,1,1,
1,1,-1,-1,-1,1,1,
1,1,1,1,-1,1,1,
1,1,1,1,-1,1,1,
-1,-1,-1,-1,-1,0,2,
1,1,1,1,2,1,1,
-1,-1,-1,-1,-1,2,0
};
char op[7]={'+','-','*','/','(',')','#'};
int indexOf(char c){
    int j;
    for(j = 0;j<7;++j){
            if(op[j]==c)
                break;
    }
    return j;
}
bool convert(char *mExp,char *bExp){
/**<
1、建立符号栈*/
Stack opStack;

/**   2、顺序扫描中序表达式
a） 是数字， 直接输出
b） 是运算符*/
int n = strlen(mExp);
int k = 0;
for(int i=0;i<n;++i){
    char c = mExp[i];
    if(isdigit(c)){
        bExp[k++]=c;
    }
    else{
        int j = indexOf(c);
        ///不是合法算符
        if(j==7)
            return false;
        ///i : “(” 直接入栈
        if(c=='('){
            ///由于我的stack是int型，这里会有类型转换
            int x = (int)c;
            opStack.Push(x);
        }
        ///ii : “)” 将符号栈中的元素依次出栈并输出, 直到 “(“, “(“只出栈, 不输出
        else if(c==')'){
           char ch;
           int xx = ch;
           opStack.GetTop(xx);
           ch = (char)xx;
           while(ch!='('){
                opStack.Pop(xx);
                bExp[k++]=(char)xx;
                opStack.GetTop(xx);
                ch = (char)xx;
           }
           opStack.Pop(xx);
        }
        ///iii: 其他符号, 将符号栈中的元素依次出栈并输出,
        ///直到遇到比当前符号优先级更低的符号或者”(“。 将当前符号入栈。
        else{
            if(opStack.GetSize()!=0){
                char ch;
                int x = (int)ch;
                opStack.GetTop(x);
                ch = (char)x;
                int column = indexOf(ch);
                int tuplE = indexOf(c);
                while(opTable[column][tuplE]!=-1 && ch != '('){
                    bExp[k++]=ch;
                    opStack.Pop(x);
                    opStack.GetTop(x);
                    ch=(char)x;
                    column=indexOf(ch);
                }
            }
            opStack.Push(c);
        }
    }
}
///扫描完后, 将栈中剩余符号依次输出
while(opStack.GetSize()!=0){
    int x;
    opStack.Pop(x);
    bExp[k++]=char(x);
}
bExp[k]='\0';
return true;
}

需要注意的是，我这里用的栈是自己写的栈，栈的元素是整型，而处理表达式用的是字符型，在程序运行过程中存在类型转换。因此，这是容易出错的。比较好的做法是在编写栈的实现的时候使用泛型编程，使得栈的数据类型可变，但是对每一种数据类型的操作都是一样的。
（4）步骤二编程实现：

/** 建立一个栈S 。从左到右读表达式，
如果读到操作数就将它压入栈S中，如果
读到n元运算符(即需要参数个数为n的运算符)
则取出由栈顶向下的n项按操作符运算，
再将运算的结果代替原栈顶的n项，
压入栈S中。如果后缀表达式未读完，
则重复上面过程，最后输出栈顶的数值则为结束。
 */
int calculate(char *bExp){
    Stack s;
    int n = strlen(bExp);
    char c;
    int x,y,op1,op2;
    int result;
    for(int i=0;i<n;++i){
        c = bExp[i];
        x = (int)c;
        if(isdigit(c)){
            s.Push(x-'0');
        }
        else{
            if(c=='+'){
                s.Pop(op2);
                s.Pop(op1);
                result = op1+op2;
                //cout<<op1<<c<<op2<<'='<<result<<endl;
                s.Push(result);
            }
            if(c=='-'){
                s.Pop(op2);
                s.Pop(op1);
                result = op1-op2;
                //cout<<op1<<c<<op2<<'='<<result<<endl;
                s.Push(result);
            }
            if(c=='*'){
                s.Pop(op2);
                s.Pop(op1);
                result = op1*op2;
                //cout<<op1<<c<<op2<<'='<<result<<endl;
                s.Push(result);
            }
            if(c=='/'){
                s.Pop(op2);
                s.Pop(op1);
                result = op1/op2;
                //cout<<op1<<c<<op2<<'='<<result<<endl;
                s.Push(result);
            }
        }

    }
    s.Pop(x);
    return x;
}

（4）测试

int main()
{
    char mExp[100],bExp[100];
    cout<<"请输入中缀表达式："<<endl;
    cin>>mExp;
    if(convert(mExp,bExp)){
         cout<<"转换得到的后缀表达式："<<endl;
         for(int i=0;i<strlen(bExp);++i)
            cout<<bExp[i]<<' ';
        cout<<endl;
    }
    cout<<"根据后缀表达式计算得到值为:"<<calculate(bExp)<<endl;
    return 0;
}

运行结果：
这里写图片描述
2、利用两个栈实现一个队列
算法原理：我们知道队列是先进先出的线性表，而栈是先进后出的线性表。那么两次先进后出，就会变成先进先出，于是编程的关键在于保证两次先进后出的顺序，比如对于输入1,2,3,4来说，到达第一个栈后输出变成4/3/2/1；而到达第二个栈后输出就变成1/2/3/4了，这就实现了队列的功能。设s1是输入的第一个栈，s2是第二个栈，那么，当s2不为空时，不可以将s1的数据导入s2，否则将打破两次先进后出的顺序。

#include "Stack.h"
///利用两个栈实现一个队列的功能
class Queue{
private:
    Stack s1,s2;///s1是输入栈、s2是输出栈
public:
    Queue(){}
    bool push(int e){
        s1.Push(e);
    }
    bool pop(int &e){
        if(s2.GetSize()!=0){
            s2.Pop(e);
            return true;
        }
        else if(s1.GetSize()!=0){
            int x;
            while(s1.GetSize()!=0){
                s1.Pop(x);
                s2.Push(x);
            }
            s2.Pop(e);
            return true;
        }
        else{
            return false;
        }
    }
};

我这里的栈都是可以无限增长的，所以不用判断s1是否为满。否则需要判断s1是否为满。
测试：

Queue q;
    q.push(1);
    q.push(2);
    int e;
    q.pop(e);
    cout<<e<<' ';
    q.push(3);
    q.push(4);
    q.pop(e);
    cout<<e<<' ';
    q.pop(e);
    cout<<e<<' ';
    q.pop(e);
    cout<<e<<' ';

运行结果：
这里写图片描述

Ajay666
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈结构的C++实现
12-01
栈结构的C++实现代码。
c与c++不同方式实现栈
03-17
### C与C++不同方式实现栈 #### 概述 本文将通过两种不同的编程方法来实现栈这一数据结构，一种是...对于初学者而言，这两种方法都提供了很好的学习机会，有助于深入理解栈这一基本数据结构的工作原理及其实现机制。
栈（c++实现）
热门推荐
echo_bright_的博客
03-01 1万+
  栈是一种特殊的线性表， 线性表是具有相同类型的n(n&gt;=0)个数据元素的有序(中间不能空位置)有限序列。   对栈的操作（增/删/读）只能通过栈的一端进行，允许操作的一端称之为栈顶，不允许操作的一端称为栈底。栈的特性为先进后出。c++实现栈，可采用如下的设计思路：   Stack是一个接口类，封装了栈的所有操作： //Stack.h #ifndef __STACK_H...
C++栈(stack)详解
w_m_x_d的博客
06-26 2243
C++栈详解
栈的C++实现
qiqi__xu的博客
04-25 117
文章目录栈的顺序储存栈的链式储存 栈是特殊的线性表，只能在尾部进行插入和删除 栈的顺序储存 #include<iostream> #include<assert.h> using namespace std; #define max_size 10 class stack_m { public: void pop_m();//弹出数组最后一个元素 void push...
栈的实现（C++）
Achiberx
11-30 812
#include #include using namespace std; template class set_stack { private: elemtype *elem; int top_p; int max_size; public: bool is_empty() const { return t
C++实现栈
bobi1024的博客
12-05 912
C++实现栈栈栈的顺序存储结构及其基本运算的实现定义一个顺序栈类1.顺序栈的初始化和销毁2.判断栈是否为空3.进栈4.出栈同时取栈顶元素 栈 栈是一种只能在一端进行插入或删除操作的线性表。表中允许进行插入、删除操作的一端称为栈顶。栈顶的当前位置是动态的，由一个被称为栈顶指针的位置提示器来提示。表的另一端称为栈底，当栈中没有数据元素时，称为空栈。栈的插入操作通常称为进栈或入栈，栈的删除操作通常称为退栈或出栈。 栈的顺序存储结构及其基本运算的实现 顺序栈的初始化和销毁 判断栈是否为空 进栈 出栈同时取栈顶元素
基于 C++线性表及其实现 栈和队列及其应用课程实验（实验报告+源码）
06-27
【作品名称】：线性表及其实现 栈和队列及其应用【课程实验】（实验报告+源码） 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 ...
使用C++实现相关算法及其数据结构源码
最新发布
08-09
栈和队列的互相模拟, 及其应用 回溯 13_app LRU(Least Recently Used) 最久未使用淘汰算法实现 LFU(Least Frequently Used) 最不经常使用淘汰算法实现 AVL 平衡二叉搜索树实现 RedBlackTree 红黑树实现 散列表实现
C++实现模板栈源代码
09-15
在本项目中，我们主要探讨...通过这个项目，我们不仅可以学习到C++模板类的使用，还能深入理解栈这一数据结构及其应用。同时，对于自定义数据结构的处理也能得到锻炼，这对于提升编程能力和解决问题的能力非常有帮助。
C++实现顺序栈的操作
11-29
下面将详细讨论如何在C++中实现顺序栈及其相关的操作。 1. **栈的基本操作**： - **push()**: 向栈顶添加元素。在顺序栈中，如果栈未满，我们将新元素直接添加到数组的最后一个位置。 - **pop()**: 移除栈顶元素...
【数据结构】c++栈的实现
芒果黑的博客
07-28 1009
栈是一种基于后进先出策略的集合类型。当你的邮件在桌上放成一叠时，使用的就是栈。新的邮件来到时你将它们放在最上面，当你有空时你会一封一封地从上到下阅读它们。这就是一种后进先出的情况。 栈的实现有两种，一种是顺序栈，一种是链式栈。顾名思义，顺序栈就是通过数组来实现，链式栈就是通过链表来实现的。 1.下面是顺序栈的代码实现： template <class T> cla...
C++栈实现
Shirven
04-28 2101
1、栈(Stack)是一种线性存储结构，它具有如下特点： （1）栈中的数据元素遵守“先进后出"(First In Last Out)的原则，简称FILO结构。 （2）限定只能在栈顶进行插入和删除操作。 2、栈的相关概念： （1）栈顶与栈底：允许元素插入与删除的一端称为栈顶，另一端称为栈底。 （2）压栈：栈的插入操作，叫做进栈，也称压栈、入栈。 （3）弹栈：栈的删除操作，也叫做出栈。 ...
数据结构——栈（C++ 实现）
weixin_74753331的博客
05-26 3598
使用C++实现栈的功能
栈的实现(C++)
Shang1031
12-20 350
通过对简单栈的基本实现代码进行分析了解加深对栈的实现和功能的印象。 · 简析栈的基础知识 · template <typename T> //模板类的使用 class miniStack //类的定义 { public: miniStack(); //定义栈 void push(const T &item); //向栈内输入数据（入栈） void pop();...
C++ 栈的实现
Slatter的博客
07-22 319
stack 类实现 点击此处浏览C++官方的stack详细内容 主要功能有以下几个 函数 功能 empty 测试 stack 是否为空 pop 从 stack 的顶部删除元素 push 将元素添加到 stack 顶部 size 返回 stack 中的元素数量 top 返回对 stack 顶部元素的引用 自己实现stack类 只要清楚栈先进后出的原理就很好实现 # include<iostream> # include<string> using n
C++中栈的实现
heifengli6666的博客
10-06 297
栈的实现 栈的特点：先进后出 #include <iostream> using namespace std; const int MAX = 6;//设置栈的长度为6 class STACK { private: int data[MAX]; int top; public: STACK(void){ top = 0; cout << "栈已被初始化!" << endl; } ~STACK(void){ cout << "栈已被销毁
栈C++实现
iuvgood
07-21 190
#include <iostream> using namespace std; typedef struct{ int *base; int *top; int stacksize; }sqstack; int initstack(sqstack &S) { S.base = new int[5]; S.top = S.base; S.stacksize = 5...
C++实现栈与队列基础及其应用
总结来说，掌握栈和队列的原理、操作以及它们在C++编程中的应用对于构建高效的数据结构至关重要，有助于解决许多实际问题中的数据管理和控制流程。理解它们的工作方式，并能够灵活运用这些数据结构，是每个程序员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值