用堆栈机实现表达式运算

最新推荐文章于 2022-11-13 22:21:21 发布
最新推荐文章于 2022-11-13 22:21:21 发布
阅读量1.3k 收藏
点赞数

前言

用堆栈机模拟实现了一个表达式求值.
使用了双栈.
没有测试除法, 以后再完善.
不过, 以后用二叉树实现了逆波兰表达式的求值, 这个版本也就不想更新了.

测试程序

/// @file StackMachine.cpp : Defines the entry point for the console application.
/// @brief 
/**
exam_4
2.用堆栈机实现表达式运算
1 + 2 * 3 - 6 = 1
*/

/** 逆波兰式的规则简化
1. 遇到优先级低于栈顶的运算符, 直接清栈运算或者运算到(为止
2. 遇到右括号, 直接清栈运算到左括号
其他情况全部压栈
*/

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

#include "LsStack.h"

void fnTestDbList(); ///< 测试CLsLinkedList<T>双链表的所有接口

int main(int argc, char* argv[])
{
    fnTestDbList();
    return 0;
}

typedef int (*PFNCALC)(int, int);

int fnCalc_add(int iLeft, int iRight)
{
    return (iLeft + iRight);
}

int fnCalc_sub(int iLeft, int iRight)
{
    return (iLeft - iRight);
}

int fnCalc_mul(int iLeft, int iRight)
{
    return (iLeft * iRight);
}

int fnCalc_div(int iLeft, int iRight)
{
    if (0 == iRight)
    {
        assert(0 != iRight);
        iRight = 1;
    }

    return (iLeft / iRight);
}

typedef struct _tag_operator
{
    _tag_operator(char cOperator, PFNCALC pfn, int iLevel)
    {
        this->cOperator = cOperator;
        this->pfn = pfn;
        this->iLevel = iLevel;
    }

    char cOperator;
    PFNCALC pfn;
    int iLevel; ///< 运算符优先级
}TAG_OPERATOR;

TAG_OPERATOR g_CalcOptAry[] = {
    TAG_OPERATOR('+', fnCalc_add, 0),
    TAG_OPERATOR('-', fnCalc_sub, 1),
    TAG_OPERATOR('*', fnCalc_mul, 2),
    TAG_OPERATOR('/', fnCalc_div, 3),
};

PFNCALC FindCalcFn(char cOpt)
{
    int iTmp =  0;
    PFNCALC pfnRc = NULL;
    
    for (iTmp = 0; iTmp < (sizeof(g_CalcOptAry) / sizeof(g_CalcOptAry[0])); iTmp++)
    {
        if (cOpt == g_CalcOptAry[iTmp].cOperator)
        {
            pfnRc = g_CalcOptAry[iTmp].pfn;
            break;
        }
    }
    
    return pfnRc;
}

int CompareOptLevel(char cOptLeft, char cOptRight)
{
    int iTmp =  0;
    int iLevelOptLeft = -1;
    int iLevelOptRight = -1;

    for (iTmp = 0; iTmp < (sizeof(g_CalcOptAry) / sizeof(g_CalcOptAry[0])); iTmp++)
    {
        if (cOptLeft == g_CalcOptAry[iTmp].cOperator)
        {
            iLevelOptLeft = g_CalcOptAry[iTmp].iLevel;
        }
        else if (cOptRight == g_CalcOptAry[iTmp].cOperator)
        {
            iLevelOptLeft = g_CalcOptAry[iTmp].iLevel;
        }

        if ((iLevelOptLeft >= 0) && (iLevelOptLeft >= 0))
        {
            break;
        }
    }

    if (iLevelOptLeft == iLevelOptRight)
    {
        return 0;
    }

    if (iLevelOptLeft > iLevelOptRight)
    {
        return 1;
    }

    return -1;
}

bool isCanPushOpt(char cOpt)
{
    bool bRc = false;
    int iTmp = 0;

    for (iTmp = 0; iTmp < (sizeof(g_CalcOptAry) / sizeof(g_CalcOptAry[0])); iTmp++)
    {
        if (cOpt == g_CalcOptAry[iTmp].cOperator)
        {
            bRc = true;
            break;
        }
    }

    return bRc;
}

bool isNum(char cIn)
{
    return ((cIn >= '0') && (cIn <= '9'));
}

int c2int(char cIn)
{
    int iRc = 0;

    if ((cIn >= '0') && (cIn <= '9'))
    {
        iRc = (cIn - '0');
    }
    else
    {
        assert(0);
    }

    return iRc; 
}

void fnTestDbList()
{
    int iTmp = 0;
    char cTmp = '\0';
    int iIndex = 0;
    
    /// 最简化的处理, 一位数字, 延后考虑复杂情况
    const char* pcInversePolandExpression = "1+2*3-6"; ///< 逆波兰表达式
    CLsStack<int> stack_data; ///< 数据栈
    CLsStack<char> stack_operator; ///< 运算符栈
    CLsStack<char>::iterator itOpt;
    char cOptFirst = '\0';
    char cOptSecond = '\0';
    int iValFirst = '\0';
    int iValSecond = '\0';
    int iCalcResult = 0;
    PFNCALC pfnCalc = NULL;

    while ('\0' != *(pcInversePolandExpression + iIndex))
    {
        cTmp = *(pcInversePolandExpression + iIndex);
        if (isNum(cTmp))
        {
            stack_data.push(c2int(cTmp));
            if (stack_operator.getLength() >= 2)
            {
                itOpt = stack_operator.begin();
                cOptFirst = *itOpt++;
                cOptSecond = *itOpt;
                if (CompareOptLevel(cOptFirst, cOptSecond) >= 0)
                {
                    if (stack_data.getLength() >= 2) 
                    {
                        iValFirst = stack_data.pop();
                        iValSecond = stack_data.pop();

                        cOptFirst = stack_operator.pop();
                        pfnCalc = FindCalcFn(cOptFirst);
                        assert(NULL != pfnCalc);
                        if (NULL != pfnCalc)
                        {
                            iTmp = pfnCalc(iValFirst, iValSecond);
                            stack_data.push(iTmp);
                        }
                    }
                }
            }
        }
        else
        {
            if (isCanPushOpt(cTmp))
            {
                stack_operator.push(cTmp);
            }
        }

        iIndex++;
    }

    // 数据栈中为 1, 0
    // 符号栈中为 +

    /// 此时, 栈中的数据运算符优先级都相同
    /// 一次计算完
    while (stack_operator.getLength() > 0)
    {
        cOptFirst = stack_operator.pop();

        if (stack_data.getLength() >= 2)
        {
            iValFirst = stack_data.pop();
            iValSecond = stack_data.pop();

            pfnCalc = FindCalcFn(cOptFirst);
            assert(NULL != pfnCalc);
            if (NULL != pfnCalc)
            {
                iTmp = pfnCalc(iValFirst, iValSecond);
                stack_data.push(iTmp);
            }
        }
    }

    /// 计算完成, 数据栈中是计算结果
    if (stack_data.getLength() >= 0)
    {
        iCalcResult = stack_data.pop();
        printf("%s = %d\n",
            pcInversePolandExpression,
            iCalcResult);
    }
    else
    {
        printf("can't calculate result, please check input\n");
    }

    printf("\n");
}

模板实现

// LsStack.h: interface for the CLsLinkedList class.
//
//

#if !defined(LSSTACK_H_82FEA8FE_F7B8_4CD7_A162_751580726632)
#define LSSTACK_H_82FEA8FE_F7B8_4CD7_A162_751580726632

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "LsDoublyLinkedList.h"

/**
栈
    栈也是线性表.
    栈是先进后出, 只操作栈顶的数据结构.
    栈是可以回溯的
    栈可以用来计算用来制作堆栈机, 用堆栈机算法来模拟逆波兰表达式的运算结果, 可以模拟汇编指令的执行, 用于虚拟机.
实现方法
    * 用链表类实现
    继承于链表, 只在头部操作(增加,删除).
    * 用数组类实现
    继承于数组, 只在尾部操作(增加,删除).
*/
template<typename T>
class CLsStack : public CLsLinkedList<T>
{
public:
    CLsStack()
    {
    }

    virtual ~CLsStack()
    {
    }

    void push(T Element);
    T pop();
};

template<typename T>
void CLsStack<T>::push(T Element)
{
    addHead(Element);
}

template<typename T>
T CLsStack<T>::pop()
{
    T Rc = (T)0;

    if (getLength() > 0)
    {
        Rc = *getHead();
        removeHead();
    }

    return Rc;
}

#endif // !defined(LSSTACK_H_82FEA8FE_F7B8_4CD7_A162_751580726632)


// LsDoublyLinkedList.h: interface for the CLsLinkedList class.
//
//

#if !defined(LSDOUBLYLINKEDLIST_H_82FEA8FE_F7B8_4CD7_A162_751580726632)
#define LSDOUBLYLINKEDLIST_H_82FEA8FE_F7B8_4CD7_A162_751580726632

/**
链表总结
空间
    链式存储
时间复杂度
    尽量避免提供非常量阶的接口
    增加操作: O(1) 常量阶, 快
    删除操作: O(1) 常量阶, 快
    修改操作:O(1) 快(条件:知道位置, 用的是先前返回的位置类或结点指针)
    查询操作:O(n) 线性阶, 慢
    随机访问:O(n) 线性阶, 慢
使用场合
    * 问题规模不确定
    * 随机访问频率低
    * 数据更新频率高(主要指的是添加和删除操作)
缺点
    * 查询速度慢(数组和链表查询速度都慢)
原生new的时间复杂度
    new实现是线性阶.
    调用的memset是线性阶, 有循环操作.
    HeapAlloc中没源码, 但是有循环操作, 是线性阶.
    new不影响时间增长率.

结论
    当算法中, new次数较少时, 可以忽略new对算法时间复杂度的影响.
    当new次数较多时, 可以一次多new几个元素(e.g. 10个), 下次就不用new, 直接取已经new好的数据操作, 等用完了, 才再次new几个元素出来.
    这样对new操作做优化, 等于自己做堆管理, 需要再做一个链表, 将new出来的10个一组的小块内存空间管理起来, 当一个类指针不用了, 就称为闲置空间, 放在内存池中. 下次不用再申请了, 可以复用.
    等链表析构时, 链表的原生操作完成后, 再一块释放内存池.
*/

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

/// ----------------------------------------------------------------------
/// CLsLinkedList 双链表 定义
/// ----------------------------------------------------------------------
template <typename T>
class CLsLinkedList  
{
public:
    /// ----------------------------------------------------------------------
    /// CLsLinkedNode 定义
    /// ----------------------------------------------------------------------
    
    /// LsDoublyLinkedList's Node
    template <typename T>
        struct CLsLinkedNode
    {
        friend CLsLinkedList<T>; ///< 不需要前向声明, 用到的时候才检查
        friend CLsLinkedList<T>::iterator;

    private:
        CLsLinkedNode(T Elem)
            :m_Elem(Elem)
            ,m_pNext(NULL)
            ,m_pPrev(NULL)
        {
        }
        
        ~CLsLinkedNode()
        {
        }

        T m_Elem; //数据元素
        CLsLinkedNode<T>* m_pPrev; //前驱
        CLsLinkedNode<T>* m_pNext; //后继
    };

    /// ----------------------------------------------------------------------
    /// 正向迭代器 定义
    /// ----------------------------------------------------------------------
    class iterator
    {
        friend class CLsLinkedList<T>;
    public:
        iterator()
        {
            m_pNode = NULL;
        }

        iterator(CLsLinkedNode<T>* pNode)
        {
            m_pNode = pNode;
        }
        
        iterator operator++()
        {
            m_pNode = m_pNode->m_pNext;
            return m_pNode;
        }
        
        iterator operator++(int)
        {
            CLsLinkedNode<T> *pTemp = m_pNode;
            m_pNode = m_pNode->m_pNext;
            return pTemp;
        }

        iterator operator--()
        {
            m_pNode = m_pNode->m_pPrev;
            return m_pNode;
        }
        
        iterator operator--(int)
        {
            CLsLinkedNode<T> *pTemp = m_pNode;
            m_pNode = m_pNode->m_pPrev;
            return pTemp;
        }
        
        T& operator* ()
        {
            return m_pNode->m_Elem;
        }
        
        bool operator!= (const iterator& obj)
        {
            return m_pNode != obj.m_pNode;
        }

        bool operator== (const iterator& obj)
        {
            return m_pNode == obj.m_pNode;
        }

    private:
        CLsLinkedNode<T>* GetNode()
        {
            return m_pNode;
        }

    private:
        CLsLinkedNode<T>* m_pNode;
    };

public:
    iterator begin()
    {
        return m_pHead;
    }

    iterator end()
    {
        return NULL;
    }

public:
    CLsLinkedList();
    virtual ~CLsLinkedList();

    /// 只提供O(1)的接口^_^

    iterator getTail() const;
    iterator getHead() const;
    inline bool isEmpty() const;
    inline size_t getLength() const;  //表长
    void clear();

    iterator addTail(T newElem);
    bool removeTail();

    iterator addHead(T newElem);
    bool removeHead();

    T getAt(iterator it) const;
    void setAt(iterator it, T newElem);
    bool removeAt(iterator it);

    bool insert(iterator it, T newElem);

private:
    CLsLinkedNode<T>* m_pHead;  //头结点
    CLsLinkedNode<T>* m_pTail;  //尾结点
    size_t m_nLength;
};

/// ----------------------------------------------------------------------
/// CLsLinkedList 实现
/// ----------------------------------------------------------------------
template <typename T>
inline size_t CLsLinkedList<T>::getLength() const
{
    return m_nLength;
}

template <typename T>
inline bool  CLsLinkedList<T>::isEmpty() const
{
    return (NULL == m_pHead) ? true : false;
}

template <typename T>
CLsLinkedList<T>::CLsLinkedList()
:m_pHead(NULL)
,m_pTail(NULL)
,m_nLength(0)
{
}

template <typename T>
CLsLinkedList<T>::~CLsLinkedList()
{
    clear();
}

template <typename T>
void CLsLinkedList<T>::clear()
{
    while (!isEmpty())
    {
        removeTail();
    }
}

template <typename T>
T CLsLinkedList<T>::getAt(CLsLinkedList::iterator it) const
{
    return *it;
}

template <typename T>
void CLsLinkedList<T>::setAt(CLsLinkedList::iterator it, T newElem)
{
    *it = newElem;
}

template <typename T>
bool CLsLinkedList<T>::insert(CLsLinkedList::iterator it, T newElem)
{
    CLsLinkedNode<T>* pNewNode = NULL;
    CLsLinkedNode<T>* pPrev = NULL;
    CLsLinkedNode<T>* pNext = NULL;

    pPrev = it.GetNode();
    if (NULL == pPrev)
    {
        return false;
    }

    pNewNode = new CLsLinkedNode<T>(newElem);
    pNext = pPrev->m_pNext;
    
    /*
    1 2 3 [6] 4 5
    3.next = 6
    4.prev = 6
    6.prev = 3
    6.next = 4
    
      1 2 3 4 5 [6]
    */
    pPrev->m_pNext = pNewNode;
    if (NULL != pNext)
    {
        pNext->m_pPrev = pNewNode;
    }

    pNewNode->m_pPrev = pPrev;
    pNewNode->m_pNext = pNext;
    m_nLength++;
    return true;
}

template <typename T>
bool CLsLinkedList<T>::removeTail()
{
    bool bRc = false;
    CLsLinkedNode<T>* pPrev = NULL;

    if (NULL == m_pHead)
    {
        return false;
    }
    
    //1 2 [3]
    if (NULL != m_pTail)
    {
        pPrev = m_pTail->m_pPrev;
        if (NULL != pPrev)
        {
            pPrev->m_pNext = NULL;
        }
        else
        {
            m_pHead = NULL;
        }
        
        delete m_pTail;
        bRc = true;
        m_pTail = pPrev;
        m_nLength--;
    }

    return bRc;
}

template <typename T>
bool CLsLinkedList<T>::removeHead()
{
    if (NULL == m_pHead)
    {
        return false;
    }
    
    //[1] 2 3
    CLsLinkedNode<T>* pNext = m_pHead->m_pNext;
    if (NULL != pNext)
    {
        pNext->m_pPrev = NULL;
    }
    else
    {
        m_pTail = NULL;
    }
    
    delete m_pHead;
    m_nLength--;
    m_pHead = pNext;
    return true;
}

template <typename T>
bool CLsLinkedList<T>::removeAt(CLsLinkedList::iterator it)
{
    CLsLinkedNode<T>* pDelNode = it.GetNode();
    CLsLinkedNode<T>* pPrev = NULL;
    CLsLinkedNode<T>* pNext = NULL;

    if ((NULL == m_pHead) 
        || (NULL == pDelNode))
    {
        return false;
    }
    
    /*
    1 2 [3] 4 5 
    2.next = 4
    4.prev = 2
    
      [1] 2 3 4 5 
      
        1 2 3 4 [5]
        
          [1]
    */
    pPrev = pDelNode->m_pPrev;
    pNext = pDelNode->m_pNext;

    if (NULL != pPrev)
    {
        pPrev->m_pNext = pNext;
    }
    else
    {
        m_pHead = pNext;
    }
    
    if (NULL != pNext)
    {
        pNext->m_pPrev = pPrev;
    }
    else
    {
        m_pTail = pPrev;
    }
    
    delete pDelNode;
    m_nLength--;
    
    return true;
}

template <typename T>
CLsLinkedList<T>::iterator CLsLinkedList<T>::addTail(T newElem)
{
    CLsLinkedList<T>::CLsLinkedNode<T>* pNewNode = new CLsLinkedList<T>::CLsLinkedNode<T>(newElem);
    
    //空表
    if (NULL == m_pHead)
    {
        m_pHead = m_pTail = pNewNode;
    }
    else 
    {
        //1 2 3 4 5 [6]
        //5.next = 6    6.prev = 5  tail = 6
        m_pTail->m_pNext = pNewNode;
        pNewNode->m_pPrev = m_pTail;
        m_pTail = pNewNode;
    }

    m_nLength++;

    return pNewNode;
}

template <typename T>
CLsLinkedList<T>::iterator CLsLinkedList<T>::addHead(T newElem)
{
    CLsLinkedList<T>::CLsLinkedNode<T> *pNewNode = new CLsLinkedList<T>::CLsLinkedNode<T>(newElem);
    
    //空表
    if (NULL == m_pHead)
    {
        m_pHead = m_pTail = pNewNode;
    }
    else 
    {
        //[6] 1 2 3 4 5 
        //1.prev = 6    6.next = 1  head = 6
        m_pHead->m_pPrev = pNewNode;
        pNewNode->m_pNext = m_pHead;
        m_pHead = pNewNode;
    }

    m_nLength++;
    return pNewNode;
}

template <typename T>
CLsLinkedList<T>::iterator CLsLinkedList<T>::getTail() const
{
    return m_pTail;
}

template <typename T>
CLsLinkedList<T>::iterator CLsLinkedList<T>::getHead() const
{
    return m_pHead;
}

#endif // !defined(LSDOUBLYLINKEDLIST_H_82FEA8FE_F7B8_4CD7_A162_751580726632)





LostSpeed
关注
用栈实现表达式运算
a1037488611的专栏
03-18 5652
1 算法思想 所包含的运算符有‘+’，‘-’，‘*’，‘/’，‘（’，‘）’。 （1）建立两个栈，一个用来存储操作数，另一个用来存储运算符,开始时在运算符栈中先压入‘/0’，一个表达式的结束符。 （2）然后从左至右依次读取表达式中的各个符号（操作数或者运算符）； （3）如果读到的是操作数直接存入操作数栈； （4）如果读到的是运算符，则作进一步判断： 若读到的是‘/0’结束符，而且此时运
使用堆栈实现对算数四则混合运算表达式的求值（C语言）
kuuhakuのblog
04-23 2636
使用堆栈实现对算数四则混合运算表达式的求值（C语言） 一个运算数和运算符之间没有空格的算术表达式字符串，采用堆栈的方法对其进行计算
使用堆栈完成计算表达式（JAVA实现）
weixin_43589025的博客
05-06 691
题目描述：对"6+3*3-3"进行计算 思路分析： （0）创建两个栈，一个用于存放数字，一个用于存放运算符 （1）通过一个index值（索引），来遍历表达式 （2）如果是一个数字，就直接进入堆栈 （3）如果是一个运算符的话： ①如果当前运算符栈为空，则直接进入堆栈 ②如果当前运算符栈不为空，则与之前的那个运算符进行优先级比较。如果优先级小于或者等于之前的那一个运算符，就需要从数栈中pop出两个数字...
利用堆栈解析算术表达式一：基本过程
02-03 514
1 本文目标 分析用堆栈解析算术表达式的基本方法。给出的示例代码能解析任何包括+，-，*，/，()和0到9数字组成的算术表达式。 2 中缀表达式和后缀表达式 中缀表达式就是通常所说的算术表达式，比如(1+2)*3-4。 后缀表达式是指通过解析后，运算符在运算数之后的表达式，比如上式解析成后缀表达式就是12+3*4-。这种表达式可以直接利用栈来求解。 3 运算...
利用堆栈实现数值表达式的计算
10-22
利用堆栈计算表达式的值，如：3×5-2+3×8/2实现+、-、×、/、（、）运算
堆栈应用——表达式计算
QS_Sun_24的博客
04-02 3114
简述：表达式在我们人类的眼里很直观简单，但想让机器理解并进行计算就是问题了，书里介绍了堆栈来变换表达式形式让机器理解的方法— —中缀表达式变换为后缀表达式，再翻译后缀表达式进行计算。但代码实现竟然只有后缀表达式到计算的这一部分，真是fuck，我又搞了好久才实现中缀变换后缀。 在机器内部，任何表达式都是由操作数、运算符和分解符（括号等）组成。本文只讨论简单的算术表达式，即只有数字和加减乘除括号。我
堆栈实现表达式运算C语言
最新发布
09-14
下面是一个使用堆栈实现表达式运算的示例代码： ```c #include #include // 定义堆栈结构 typedef struct { int top; // 栈顶指针 int *data; // 数据数组 } Stack; // 初始化堆栈 void initStack(Stack *...
利用堆栈进行表达式求值
cfz751740465的博客
02-20 1152
基本策略：将中缀表达式转换为后缀表达式，然后求值 中缀表达式转换为后缀表达式的流程： 从头到尾读取中缀表达式的每个对象，对不同的对象按不同的情况处理 (1) 运算数：直接输出 (2) 左括号：压入堆栈，入栈前左括号的优先级最高, 入栈之后其优先级降到最低 (3) 右括号：将栈顶的运算符弹出并输出，直到遇到左括号（出栈，不输出） (4) 运算符： [1] 若优先级大于栈顶运算符时，则把它压栈 [2] 若优先级小于栈顶运算符时，将栈顶运算符弹出并输出；再比较新的栈顶运算符，直到该运算符大于栈顶运...
堆栈应用四则运算表达式求值
qq_42283621的博客
04-20 1480
以最简单的方式实现几个C语言课程设计的常见题目，适合大一或者刚学习C语言的同学学习参考。使用Code::Blocks编译器创建的纯C项目，将其中的源码粘贴进其他编译器或C++项目也可直接运行。因为部分同学没有学习过数据结构，所以尽量使用传统的数组进行存储，规避没有学习过的知识点，但鼓励大家自己改进。为了使得程序更加简单方便阅读，基本上没有进行对用户输入的容错，可以自己添加。 Code::Blocks安装和使用 https://blog.csdn.net/qq_42283621/article/details
利用堆栈实现波兰表达式实现后缀表达式计算
09-01
C++语言，利用堆栈实现波兰表达式实现后缀表达式计算。
利用栈来实现表达式的计算（+ -* /）
12-05
主要使用队列将输入表达式转换为后缀表达式，然后利用栈实现表达式的计算，..................................................................................................................................
堆栈实现计算数学表达式
Y673582465的专栏
06-28 2133
堆栈模拟数学表达式
用栈实现简单表达式的计算
1180610212的博客
03-05 464
对于一个表达式，比如： 1+2*3 我们分两步走， 第一步 将中缀表达式转换为后缀表达式 这里我们需要用到栈和队列。栈用来临时存放操作符，队列用来保存后缀表达式。同时，我们还需要一个结构体node来同时表示操作数和操作符。 struct node{ double num; char op; bool flag; }; stack<node> s; queue<node> q; 如果遇到操作数，我们就将其入队列；如果遇到操作符，我们需要比较其与栈顶操作符的优先级，当当前操作符
堆栈实现表达式求值
treefriend博客
11-13 1403
表达式求值主要集中在算符的优先级如何处理的问题，将操作数和运算符的进出栈加以转化。(教材案例的具体实现）
堆栈实现的数学运算表达式计算
weixin_43740322的博客
11-16 882
堆栈实现的数学运算表达式计算 此处运算表达式为简单数学运算表达式，只包含+，-，*，/，及（，） 输入的为一个String字符串 输入 > cout << "Input" << endl; string a; cin >> a; MatchedPairs(a); 首先进行括号匹配 > void MatchedPairs(s...
表达式计算
kzzhr
04-30 5422
题目 输入一个表达式，计算出它的值。运算符有 + - × / （ ）。 思路 这是我们学栈时碰到的一个问题，大体方法是利用双栈把中缀表达式转换成后缀表达式进行计算 ------------------------------------------------------------------------------------------------ 1.拆分数字与运算符
DS堆栈--表达式计算
半途行走的博客
09-18 1797
题目描述 计算一个表达式的运算结果 使用C++自带stack堆栈对象来实现 参考课本的伪代码，把伪代码改造成可运行的代码 课本伪代码请下载本附件：表达式伪c代码 例如 1.Push (OPTR, ‘#’);表示把字符#压入堆栈OPTR中，转换成c++代码就是OPTR.push(’#’); 2.Pop(OPND, a); 表示弹出栈OPND的栈顶元素，并把栈顶元素放入变量a中。因此改成c++代码是...
表达式运算
weixin_43257196 的博客
06-02 365
number.c #include <stdio.h> #include <ctype.h> #include "./include/mec.h" #include "./include/mecError.h" #include "./include/number.h" extern const char *errMess; typedef struct ARG { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值