链表，数组实现堆栈，表达式计算

最新推荐文章于 2022-05-20 23:30:00 发布
最新推荐文章于 2022-05-20 23:30:00 发布
阅读量229 收藏
点赞数
文章标签： 堆栈C++实现 中缀转后缀 表达式计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41951198/article/details/88362479
版权
本文介绍了使用C++通过数组和链表两种方式实现堆栈，并应用于表达式的中缀转后缀及计算。分别提供了ArrayStack和LinkStack的实现，以及Test和Expression类的详细说明，最后在Main()函数中进行了测试。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、 结果显示

  1. 堆栈实现测试 Test.h
    在这里插入图片描述
  2. 表达式运算： Expression.h
    在这里插入图片描述
    二、 ArrayStack.h

 #include<iostream>
    using namespace std;
    
    const int Max_size = 128;
    
    template<typename T>
    class ArrayStack
   {
    public:
        ArrayStack()
        {
            count = 0;
            array = new T[Max_size];
        };
        ~ArrayStack()
        {
            if(count == 0)
        {
            delete array;
            cout<<endl;
            cout<<"栈为空析构"<<endl;
        }
        else
        {
            while(count > 0)
                this->pop();
            delete array;
            cout<<endl;
            cout<<"清除栈内元素析构"<<endl;
        }
    };
 	T pop()    //弹栈
	{
   		 if(count < 0 )
   		 {
    	    cout<<endl;
    	    cout<<"弹栈时：栈内元素数量有误！"<<endl;
   		 }
	    if(count == 0)
  	    {
     	   cout<<endl;
           cout<<"弹栈时：栈为空！"<<endl;
        }
        else
            return array[(count--)-1];
   	 }

    void push(T data)  //推栈
    {
        if(count < 0 )
        {
            cout<<endl;
            cout<<"推栈时：栈内元素数量有误！"<<endl;
        }
        else
            array[(++count)-1] = data;
    }

    int size()   //栈内元素个数
    {
        return count;
    }

    bool isEmpty()   //判断栈内是否为空
    {
        return count == 0?1:0;
    }

    T top()      //返回栈顶元素
    {
        if(count == 0)
            cout<<"栈顶：栈为空栈！！！"<<endl;
        else
            return array[count-1];
    }

    void Show()
    {
        if(count<0)
        {
            cout<<endl;
            cout<<"Show：堆栈内元素个数有误！"<<endl;
        }
        if(count == 0)
        {
            cout<<endl;
            cout<<"Show：堆栈为空！"<<endl;
        }
        else
        {
            int i = count;
            cout<<endl;
            cout<<"Show：堆栈内元素为："<<"[";
            for(; i>1; i--)
                cout<<array[count-i]<<",";
            cout<<array[count-1];
            cout<<"]"<<endl;
        }
    }
    int count;
    protected:
        T *array;
         };

三、 LinkStack.h

#include<iostream>
using namespace std;

template<typename T>
class LinkStack
{
public:
    int count;

    struct Node
    {
        T data;
        Node *next;
    };

    LinkStack()
    {
        count = 0;
        head = new Node;
        head->next = NULL;
    };
    ~LinkStack()
    {
        if(count == 0)
        {
            delete head;
            cout<<endl;
            cout<<"栈为空析构"<<endl;
        }
        else
        {
            while(count > 0)
            {
                this->pop();
            }
            delete head;
            cout<<endl;
            cout<<"清除栈内元素析构"<<endl;
        }
    };

    T pop()    //弹栈
    {
        if(count < 0 )
        {
            cout<<endl;
            cout<<"栈内元素数量有误！"<<endl;
        }
        if(count == 0)
        {
            cout<<endl;
            cout<<"栈为空！"<<endl;
        }
        else
        {
            Node *p = head;
            int n = count;
            for(int i = 0; i<count; i++)
                p = p->next;
            count--;
            return p->data;
        }
    }

    void push(T data)  //推栈
    {
        if(count < 0 )
        {
            cout<<endl;
            cout<<"栈内元素数量有误！"<<endl;
        }
        if(count >= 0)
        {
            Node *p = head;
            Node *ptemp = new Node;
            for(int i =0; i<count; i++)
                p = p->next;
            ptemp->data = data;
            ptemp->next = p->next;
            p->next = ptemp;
            p = ptemp;
            count++;
        }
    }

    int size()   //栈内元素个数
    {
        return count;
    }

    bool isEmpty()   //判断栈内是否为空
    {
        return count == 0?1:0;
    }

    T top()      //返回栈顶元素
    {
        if(count == 0)
            cout<<"栈为空栈！！！"<<endl;
        else
        {
            Node *p = head;
            for(int i = 0; i<count; i++)
                p = p->next;
            return p->data;
        }
    }

    void Show()
    {
        if(count<0)
        {
            cout<<endl;
            cout<<"堆栈内元素个数有误！"<<endl;
        }
        if(count == 0)
        {
            cout<<endl;
            cout<<"堆栈为空！"<<endl;
        }
        else
        {
            Node *p = head;
            int i = count;
            cout<<endl;
            cout<<"堆栈内元素为：";
            for(int i = 1; i<count+1; i++)
            {
                p = p->next;
                cout<<p->data<<"，";
            }
            cout<<endl;
        }
    }
private:

    Node *head;
};

四、Test.h

#include<iostream>
//#include "ArrayStack.h"
#include"LinkStack.h"
using namespace std;

Test()
{
    ArrayStack<char> a1;
    LinkStack<char> l1;
    //a1 = new ArrayStack<T>;
    //l1 = new LinkStack<T>;
    cout<<"栈内元素个数：";
    cout<<"数组："<<a1.size()<<"！！"<<"链表："<<l1.size()<<"！！"<<endl;
    cout<<endl;
    cout<<"一、推栈！！！"<<endl;
    cout<<"数组实现>>";
    for(int i=0; i<10; i++)
        a1.push('a'+i);
    cout<<"栈内元素个数："<<a1.size()<<"。";
    a1.Show();
    cout<<endl;
    cout<<"链表实现>>";
    for(int i=0; i<10; i++)
        l1.push('a'+i);
    cout<<"栈内元素个数："<<l1.size()<<"。";
    l1.Show();
//************************************************
    cout<<endl;
    cout<<"二、弹栈！！！"<<endl;
    cout<<"数组实现>>";
    int n = a1.size();
    cout<<"弹出栈内后一半元素！"<<"*****"<<"[";
    for(int i=n; i>n/2+1; i--)
        cout<<a1.pop()<<",";
    cout<<a1.pop()<<"]"<<endl;
    cout<<"栈内元素个数为："<<a1.size()<<"。"<<endl;
    cout<<"链表实现>>";
    int m = l1.size();
    cout<<"弹出栈内后一半元素！"<<"*****"<<">";
    for(int i=m; i>m/2+1; i--)
        cout<<l1.pop()<<",";
    cout<<l1.pop()<<"<"<<endl;
    cout<<"栈内元素个数为："<<l1.size()<<"。"<<endl;
//************************************************
    cout<<endl;
    cout<<"三、判断栈是否为空！！！"<<endl;
    cout<<"数组实现>>";
    if(!a1.isEmpty())
    {
        cout<<"栈内非空！！";
        a1.Show();
    }
    else
        cout<<"空栈！！！"<<endl;
    cout<<"链表实现>>";
    if(!l1.isEmpty())
    {
        cout<<"栈内非空！！";
        l1.Show();
    }
    else
        cout<<"空栈！！！"<<endl;
//************************************************
    cout<<endl;
    cout<<"四、返回栈顶元素："<<endl;
    cout<<"数组实现>>";
    cout<<a1.top()<<endl;
    cout<<"链表实现>>";
    cout<<l1.top()<<endl;
    cout<<"栈内元素个数：数组>>"<<a1.size()<<endl;
    cout<<"栈内元素个数：链表>>"<<l1.size()<<endl;
    return 0;
}

五、Expression.h

#include <iostream>
#include"ArrayStack.h"
#include <queue>
#include <string>
#include <sstream>

class Expression
{
public:
    Expression();        //构造函数  输入
    Expression(string str);   //构造函数给定默认算式
    void operator=(string str);   //m_string = str
    double Calculate();
private:
    queue<string> Divide2Item();     //区分数字和操作符 获取为队列
    ArrayStack<string> Change2Postfix();   //中缀转后缀
    int Size();    //计算算式长度
    bool isBacketPair();   //判断括号是否匹配
    bool isNum(char c);          //判断是否为数字

    string m_string;       //输入的算式
};

Expression::Expression()
{
    string exp ;
    cout<<"请输入运算式：";
    cin>>exp;
    this->m_string = exp;
}

Expression::Expression(string str)
{
    this->m_string = str;
}

int Expression::Size()
{
    return m_string.size();
}

bool Expression::isBacketPair()
{
    ArrayStack<char> Backet;
    int n = Size();
    for(int i =0; i < n; i++)
    {
        char c = m_string.at(i);
        switch(c)
        {
        case '(':
            Backet.push(c);
            break;
        case ')':
            if(Backet.isEmpty())
                return false;
            else
                Backet.pop();
            break;
        default:
            break;
        }
    }
    return Backet.isEmpty();
}

bool Expression::isNum(char c)
{
    switch(c)
    {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case '.':
        return true;
        break;
    case '+':
    case '-':
    case '*':
    case '/':
    case '(':
    case ')':
        return false;
        break;
    default:
        return false;
    }
}

void Expression::operator=(string str)
{
    this->m_string = str;
}

queue<string> Expression::Divide2Item()
{
    queue<string> que;
    string str = "";

    if(!isBacketPair())
    {
        cout<<endl;
        cout<<"输入有错，括号配对，请重新输入！！"<<endl;
    }

    for(int i = 0; i < Size(); i++)
    {
        char cc;
        cc = m_string.at(i);
        if(isNum(cc))
        {
            str += m_string.at(i);
            if(i == Size()-1)
                que.push(str);
        }
        else
        {
            if(str.size() != 0)
                que.push(str);
            str = m_string.at(i);
            que.push(str);
            str = "";
        }
    }
    return que;
}

ArrayStack<string> Expression::Change2Postfix()
{
    queue<string> que = Divide2Item();
    ArrayStack<string> OperStack;
    ArrayStack<string> PostStack;
    int LBacktet = 0;
    string str;
    while(!que.empty())
    {
        str = que.front();
        que.pop();
        if(str == " ")
            continue;
        if(str == "(")
        {
            OperStack.push(str);
            LBacktet++;
            continue;
        }

        if(str == ")")
        {
            while(!OperStack.isEmpty()&&OperStack.top() != "(")
                PostStack.push(OperStack.pop());
            if(!OperStack.isEmpty())
            {
                LBacktet--;
                OperStack.pop();
            }
            continue;
        }
        if(str == "+"||str == "-")
        {
            if(OperStack.isEmpty()||OperStack.top() == "(")
                OperStack.push(str);
            else
            {
                while((OperStack.top() =="+"||OperStack.top() =="-"||OperStack.top() =="*"||OperStack.top() =="/")&& !OperStack.isEmpty())
                    PostStack.push(OperStack.pop());
                OperStack.push(str);
            }
            continue;
        }
        if(str == "*" || str == "/")
        {
            if (OperStack.isEmpty() || OperStack.top() == "("  || OperStack.top() == "-" || OperStack.top() == "+")
                OperStack.push(str);
            else
            {
                PostStack.push(OperStack.pop());
                OperStack.push(str);
            }
            continue;
        }
        else
        {
            PostStack.push(str);
            continue;
        }
    }
    while (!OperStack.isEmpty())
    {
        if(OperStack.top() != "(")
            PostStack.push(OperStack.pop());
    }
    while(!PostStack.isEmpty())
        OperStack.push(PostStack.pop());   //倒序  为进行计算时堆栈LIFO
    return OperStack;
}

double Expression::Calculate()
{
    ArrayStack<string> PostStack = Change2Postfix();
    if(PostStack.isEmpty())
        return 0;
    ArrayStack<double> Num;
    string str;
    char ch;
    double num,minu,divi;
    while(!PostStack.isEmpty())
    {
        str = PostStack.pop();
        ch = str[0];
        switch(ch)
        {
        case '*':
            num = Num.pop() * Num.pop();
            Num.push(num);
            break;
        case '+':
            num = Num.pop() + Num.pop();
            Num.push(num);
            break;
        case '-':
            minu = Num.pop();
            num = Num.pop()-minu;
            Num.push(num);
            break;
        case '/':
            if(Num.top() != 0)
            {
                divi = Num.pop();
                num = Num.pop()/divi;
                Num.push(num);
            }
            else
            {
                cout<<endl;
                cout<<"除数为0 ，出错！！"<<endl;
            }
            break;
        default:
            double a;
            istringstream istr(str);
            ostringstream ostr ;
            istr>>a;
            ostr<<a;
            Num.push(a);
            break;
        }
    }
    return Num.top();
}

六、Main()

#include"Expression.h"
#include "Test.h"
int main()
{
      Test();
//    Expression expr;
//    cout<<"计算已经定义号的算式，请随机输入一个数字，点击回车！！"<<endl;
//    Expression expr1;
//    expr1 = "52.1-(2.0*4.2-2)/3.1+3";
//    cout << "输入的算式结果为******************: "<<expr.Calculate()<<endl;
//    cout << "已经定义的算式结果为**************: "<<expr1.Calculate()<<endl;
}
菜宁心。
关注
利用堆栈实现数值表达式的计算
10-22
利用堆栈计算表达式的值，如：3×5-2+3×8/2实现+、-、×、/、（、）运算
C/C++ 数组链表表达式计算
dingchaochao_9110的博客
10-09 398
国庆期间，自己搞了C/C++编译环境（cygwin其实比mingw好安装一些），跟着敲了一些代码，记录一下： /* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ /* ...
【数据结构与算法】数组实现栈，单链表实现栈，用栈实现综合运算器calculator，前缀表达式，中缀表达式，后缀表达式计算机求值过程，中缀表达式转后缀表达式
m0_52586550的博客
05-20 167
栈，前中后缀表达式
下推栈 中缀-后缀表达式转换 后缀表达式求值 数组与链表实现
weixin_30741653的博客
03-23 148
Item.h (自定义类型) : 1 typedef double Item; STACK.h (下推栈接口) : 1 #include "Item.h" 2 3 bool STACKerror(int i); 4 void STACKinit(int); 5 int STACKempty(void); 6 void STACKpush(Item); ...
使用数组和链表的方式实现栈
Kato_op的博客
05-15 867
使用 数组和链表 的方式实现 栈 数组实现栈： public class Stack&lt;Item&gt; implements Iterable&lt;Item&gt; { private Item[] a; // 数组表示栈，栈顶在最大的下标。 private int n; // 栈内元素的个数 /** * 初始化一个...
C语言实现堆栈计算复杂表达式程序
- 栈的实现，包括动态数组或链表的创建、使用、增减操作等。 - 循环和条件判断语句，用于控制表达式的扫描和运算的执行。 - 函数的使用，将复杂的逻辑拆分为模块化函数，例如主表达式计算函数、递归处理括号内的子...
递归实现的表达式计算
11-20
虽然字符数组在表达式计算的递归实现中可能更合适，但这也取决于具体实现和性能需求。例如，字符数组在处理大型表达式时可能需要更多的内存，而链表则可能更适合动态变化的结构。 总之，递归实现的表达式计算是一种...
链表实现堆栈仿真：libstack深度解析
链表堆栈与数组堆栈是堆栈数据结构的两种不同实现方式。数组堆栈通过数组来存储堆栈元素，其优点是访问元素的时间复杂度为O(1)，但在插入和删除操作时可能需要移动元素，特别是在栈满时可能需要扩展数组。相比之下，...
Java堆栈实现的表达式计算器
另外，也可以通过数组或者链表手动实现堆栈结构。 3. 运算逻辑：处理运算符的逻辑需要根据运算符优先级和表达式的具体要求来编写。需要编写算法以确保计算顺序正确，保证计算的准确性。 4. 错误处理：计算器应该...
数据结构课程作业 单链表 双链表 线性表 堆栈 等课程编程作业
08-07
创建线性表，比较数组和链表实现的性能差异；搭建堆栈并实现压栈、弹栈操作；以及设计和实现不同类型的二叉树结构。 通过这些练习，你不仅可以掌握基本数据结构的使用，还能了解它们在实际问题中的应用，这对于提升...
数据结构之用数组和链表实现栈
郑小小小小源的博客
01-17 343
本文解决的问题是： 8. 分别用数组和量表实现堆栈各项功能。 用数组实现，代码如下： /********************8、分别用数组和量表实现堆栈各项功能*********************************/ /*********************8.1、用数组实现堆栈各项功能****************************/ #include
用数组或链表实现栈及栈的应用(中缀表达式转后缀表达式)
学习笔记
01-20 286
代码实现 package com.whb.stack; import java.util.Scanner; public class ArrayStackDemo { public static void main(String[] args) { //测试一下ArrayStack 是否正确 //先创建一个ArrayStack对象->表示栈 ArrayStack stack = new ArrayStack(4); Str.
栈的数组和链表实现以及用栈实现中缀表达式转换后缀表达式并求值
阿星的博客
07-26 449
栈 栈的定义 教科书上栈的定义是这样的：只允许在表的末端进行插入和删除的线性表。允许插入和删除的一端叫做栈顶（top），另一端叫做栈底（bottom）。栈中没有元素的时候是一个空栈。那我们看图为例： 这就是一个栈的结构，他只允许从top端插入删除，bottom端是封闭的。有一组数据data1，data2，data3入栈的时候是顺序的，那么出栈的时候就刚好倒过来，最后一个入栈的先出栈，最早一个入栈的最后出栈。我们把这个规则叫后进先出（LIFO）。 栈的代码实现 栈作为一种顺序表，可以通过数组和链表这两种方法
栈（基于数组实现和链表实现）
weixin_40496794的博客
08-28 428
一、基于数组实现的顺序栈 #include<stdio.h> #include<stdlib.h> #define maxsize 100 //栈的数组结构体 typedef struct Stack { char data[maxsize]; // 数组实现栈内元素定位 int top; // 作为数组下标 int buttom; }Array_Stack; // 创建一个空栈 Array_Stack* Create_Stack() { Array_Stack* st
C语言堆栈实现表达式运算
一个安静的程序员
09-16 751
表达式求值，这里用的是算符优先法的方式实现。任何一个表达式都可以由操作数、运算符和界限符组成，算符之间的关系有三种：&gt; &lt; =，介于这三种关系，我们可以列出所有的关系            +               -             *             /           (              )             # ----------...
c语言堆栈链表,用链表制作堆栈算法
weixin_39899226的博客
05-22 78
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include"stdafx.h"#include"iostream"usingnamespacestd;structNODE{chardata;structnode*next;};intcheck(char*top,inti){if(top->data==-1){i=0;return(i);}else{i=2;return(i...
数据结构-c++堆栈实现四则运算
qq_44157558的博客
11-03 1688
通过栈来实现简单的四则运算，数字0~9，不考虑负数，但是可以带括号。用的c++。结果是double精度。 一、前中后缀表达式。 先解释一下算术表达式的前中后缀表达式，例如下面的一个简单的二叉树： 每一个二叉树都有他自己的左子树和右子树，以及根。 前缀表达式的顺序就是：根左右。就上面的二叉树而言就是：+A/*B-C+DFE。 中缀表达式的顺序就是：左根右。即我们正常的顺顺序：A+B*C-D+F/E...
使用数组和链表实现栈和队列的复杂度分析
mcrwayfun，欢迎你
11-13 2661
​ 抽象数据类型（abstract data type，ADT）是带有一组操作的一些对象的集合 1 表ADT A1,A2,⋯&amp;ThinSpace;,AN A_1,A_2,\cdots,A_N A1​,A2​,⋯,AN​ ​ 如上，这是一个大小为N的表。当然，若N为0，则称其为空表。 ​ 对于除空表以外的任何表，A1可以看作是A2的前驱，而A2则是A1的后继。在一个表中，表中第一个元素是A1...
基于数组或链表的堆栈实现
秋枫林的专栏
08-20 2500
本文使用C语言，给出了堆栈的两种实现：基于数组和基于链表的实现方式。堆栈是一种常用的数据结构，具有“后进先出（Last In First Out）”的特性，常用来进行函数调用时候的参数传递，解决递归函数书的非递归实现，表达式中的括号匹配等问题。堆栈的常用操作如下： createStack(st)：建立一个空栈 push(st, x)：将元素x压入栈st当中，使之成为栈顶
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值