计算器（链表实现）

最新推荐文章于 2021-11-24 18:28:02 发布
最新推荐文章于 2021-11-24 18:28:02 发布
阅读量2.2k 收藏 7
点赞数 1
分类专栏： 我的小项目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29486343/article/details/47730487
版权

思路：
1.分为两步计算，第一步先计算括号里面的数据！没计算完一个括号以后，判断是否括号已经消除完毕，消除完毕结束循环
2.消除完，先计算乘除后计算加减，（在处理括号理同时含有乘除和加减时，调用此过程）
3.存储过程采用双向链表存储
总结：
1.要画出循环图来，保证思路清晰！每个细节要注意到并以适当的方式改正过来！
漏洞：
由于采用的是字符数组的形式存储数字，但是不会把负数和小数点以数组的形式存储进去，所以整个过程当中，每步骤运算不能出现负数，和小数点，才能正常运行下来~

#include<stdlib.h>
#include<string.h>
#include<conio.h>
#include<stdio.h>
#include<iostream>
using namespace std;

//---------------------------------------------------存储每个符号的单元-----------------------------------------
class node
{
public:
    char x;                 //存储输入的符号！
    node *prior;                //前驱结点，记录上一个字符；
    node *next;             //后继结点，记录下一个节点的存储的字符；
};
//--------------------------------------------------计算器M类------------------------------------------------------------
class M
{
public:
    M ();
    void create ();                 //创建并存储表达式
    int pankong ();                 //是否括号已经消除完毕
    void xiaokuo ();                    //消除括号过程，
    void Fleftright ();             //确定第一个含有右括号的节点地址与其对应的含有左括号的节点地址                                            
    void jiSUM1 ();                 //用于 * /，计算两边的乘或者除过程
    void jiSUM2 ();                 //用于 + -，计算两边的乘或者除过程
    void GetLeftsum1 ();                    //用于 * /，左边字符转化成整数型
    void GetRightsum1 ();               //用于 * /，右边的字符转化成整数型
    void GetLeftsum2 ();                    //用于 + - ，左边字符转化成整数型
    void GetRightsum2 ();               //用于+  -  ，右边的字符转化成整数型
    void xiSUM ();                  //用于把计算得到的结果从整数型转化成字符型添加进去
    void tianjia ();                    //删除原来字符添加新的字符进去（包含在xiSUM()）中
    int ok1 ();                         //判断括号里是否所有的 *  和 /    消除完毕！
    int ok2 ();                         //判断括号里是否所有的 +  和 -  消除完毕！
    void show ();                       //输出各个节点(数据)，最后不含括号和运算符！
    void    XXX1 ();                        //消除括号过程
    void XXX2 ();                       //括号消除完，计算不含括号的式子过程！
private:
    node *Head;
    node *New;
    node *Tail;
    node *Fleft;            //记录第一个右括号节点对应的含有左括号的节点地址
    node *Fright;           //记录第一个含有右括号的节点地址
    node *fleft;            //记录算式最左边的位置
    node *fright;           //记录算式最右边的位置
    int count;            //总的个数节点个数
    int Leftsum;            //左边的数
    int Rightsum;       //右边的数
    int SUM;                //左右两个数运算得到的数
    char a[10];     //存储数值转化成字符的数组
    int T;              //记录计算结果SUM的位数
};

M:: M ()
{
    Head = 0;
    Tail = 0;
    count = 0;
    Leftsum = 0;
    Rightsum = 0;
    T = 0;
    SUM = 0;
    a[10] = '0';
}

//--------------------------------------------------void create ()---------------------------------------------------
void M:: create()
{
    while (1)
    {
        New = new node;
        count++;
        cin>>New->x;
        if (count == 1)
        {
            Head = Tail = New;
        }
        else
        {
            Tail->next = New;
            New->prior = Tail;
            Tail = New;
        }
        if (New->x == '=')
        {
            New->next = 0;
            node *HHead = new node;
            HHead->x = '=';
            HHead->next = Head;
            Head->prior = HHead;
            break;
        }   
    }
}
//--------------------------------------------------int M:: pankong ()  是否含有括号-------------------------

int M:: pankong ()              
{
    node *p = Head;
    for (p ; p != 0 ;p = p->next)               //记住以后的循环要有终止条件！！！
    {
        if (p->x == ')' )
        {           
            return 1;       
        }
                        //若还含有括号返回1
    }
    return 0;                           //不含有括号返回0
}
//--------------------------------------------------void Fleftright ()每次取得第一个右括号和对应左括号的地址！-------------------------
void M:: Fleftright ()
{
    node *p = Head; 
    for (p ; p != 0 ; p = p->next )
    {   
        if ( p->x == ')' )
        {   Fright = p;  break; }       //取得第一个右括号的地址！                                  
    }
    if (p == 0)
    {
        Fright = Fleft = Head;                      //找完了，没括号了都指向头指针
    }                                                   
    p = Fright; 
    for ( p ; p != 0 && p ->x != '='  ; p = p->prior )
    {   
        if (p->x == '(')
        {   Fleft = p;  break; }            //取得第一个左括号的地址！

    }       
}                       


//-----------------------------------------------void GetLeftsum1 ()取得符号左边的int数值-------------------------------
void M:: GetLeftsum1 ()
{
    node *p = Fleft;                                    //假如消除完括号，那么 Fleft = Fright = Head;
    for (p ; p ->x != ')'&& p != 0 ; p = p->next)
    {
        if (p->x == '*' || p->x == '/')
        {
            int c = 1;
            node *q = p->prior; 
            for (q  ; ( q->x != '+'&&q->x != '-'&&q->x != '(' &&q->x != '=' ) ; q = q->prior)           //????????
            {                           
                Leftsum = Leftsum + c * ( (q->x)-'0' ); 
                c = c * 10;                                                         
            }
            fleft = q;
            break;          
        }                   
    }
}

//-----------------------------------------------void GetRightsum1 ()---取得右边的int数值----------------------------
void M :: GetRightsum1 ()
{
    node *p = Fleft;    
    int i = 0, c = 1;
    for (p ; p->x != ')' && p != 0; p = p->next)
    {
        if (p->x == '*' || p->x == '/')
        {
            node *q = p->next; 
            for (q  ;  (q->x != '+'&&q->x != '-'&&q->x != ')'&&q->x != '*'&&q->x != '/'&&q->x != '=') ; q = q->next)
            {
                i++;
            }   fright = q;
            for (q = q->prior; i >=1 ; q = q->prior)
            {
                Rightsum = Rightsum + c * ( (q->x)-'0' );   
                c = c * 10; 
                i--;
            }
        break;   
        }         
    }
}

//-----------------------------------------------void GetLeftsum2 ()取得符号左边的int数值-------------------------------
void M:: GetLeftsum2 ()
{
    node *p = Fleft;    
    for (p ; p ->x != ')'&& p != 0; p = p->next)
    {
        if (p->x == '+' || p->x == '-')
        {
            int c = 1;
            node *q = p->prior; 
            for (q  ; q->x != '(' && q->x != '=' ; q = q->prior)            
            {                           
                Leftsum = Leftsum + c * ( (q->x)-'0' ); 
                c = c * 10; 
        //      if (q == Head)
        //          break;
            } fleft = q;
            break;          
        }                   
    }
}

//-----------------------------------------------void GetRightsum2 ()---取得右边的int数值----------------------------
void M :: GetRightsum2 ()
{
    node *p = Fleft;    
    int i = 0, c = 1;
    for (p ; p->x != ')' && p != 0; p = p->next)
    {
        if (p->x == '+' || p->x == '-')
        {
            node *q = p->next; 
            for (q  ;  ( q->x != '+'&&q->x != '-'&&q->x != ')' &&q->x != '=') ; q = q->next)
            {
                i++;
            }   fright = q;
            for (q = q->prior; i >= 1 ; q = q->prior)
            {
                Rightsum = Rightsum + c * ( (q->x)-'0' );   
                c = c * 10; 
                i--;
            }
            break;   
        }      
    }
}
//------------------------------------------------------void M:: jiSUM1 ()  计算乘除左右括号结果SUM用于******和  ------------------------------------------
void M:: jiSUM1 ()               
{
    node *p = Fleft;                    //第一个右括号对应的左括号,如果没括号了，都指向头指针
    for (p ; p->x != ')' && p != 0; p = p->next)
    {
        if (p->x == '*' )
        {   
            SUM = Rightsum * Leftsum;
            Leftsum = 0;
            Rightsum = 0;
            break;
        }
        if (p->x == '/')
        {
            SUM = Leftsum / Rightsum;
            Leftsum = 0;
            Rightsum = 0;
            break;
        }
    }
}           
//------------------------------------------------------void M:: jiSUM2 ()  计算乘除左右括号结果SUM用于+++和---- ------------------------------------------
void M:: jiSUM2 ()               
{
    node *p = Fleft;                    //第一个右括号对应的左括号
    for (p ; p->x != ')' && p != 0; p = p->next)
    {
        if (p->x == '+' )
        {
            SUM = Rightsum + Leftsum;
            Leftsum = 0;
            Rightsum = 0;
            break;
        }
        if (p->x == '-')
        {
            SUM = Leftsum - Rightsum;
            Leftsum = 0;
            Rightsum = 0;
            break;
        }
    }
}
//-----------------------------------------------void M:: xiSUM ()整数型转化成字符型，并删除原来字符添加新的字符进去------------------------------
void M:: xiSUM ()
{   
    if (SUM >=0 && SUM < 10)
    {   
        a[1] = SUM + '0';  T = 1;
        tianjia ();
    }
    else if (SUM >=10 && SUM < 100)
    {
        a[2] = (SUM % 10) + '0';
        a[1] = (SUM / 10) + '0';
        T = 2;
        tianjia ();
    }
    else if (SUM >=100 && SUM <1000)
    {
        a[3] = (SUM %10) + '0';
        a[2] = (SUM % 100) /10 + '0';
        a[1] = (SUM /100) + '0';
        T = 3;
        tianjia ();
    }
    else if (SUM >=1000 && SUM <10000)
    {
        a[4] = (SUM %10) + '0';
        a[3] = (SUM % 1000 % 100) /10 + '0';
        a[2] = (SUM % 1000 )  / 100 + '0';
        a[1] = (SUM / 1000) + '0';
        T = 4;
        tianjia ();
    }
    else if (SUM >=10000 && SUM <100000)
    {
        a[5] = (SUM %10) + '0';
        a[4] = (SUM % 10000 % 1000 %100) /10 + '0';
        a[3] = (SUM % 10000 % 1000)  / 100 + '0';
        a[2] = (SUM % 10000) / 1000 + '0';
        a[1] = (SUM / 10000) + '0'; 
        T = 5;
        tianjia ();
    }
    else if (SUM >=100000 && SUM <1000000)
    {
        a[6] = (SUM %10) + '0';
        a[5] = (SUM % 100000 % 10000 % 1000 % 100) /10 + '0';
        a[4] = (SUM % 100000 % 10000 % 1000)  / 100 + '0';
        a[3] = (SUM % 100000 % 10000) / 1000 + '0';
        a[2] = (SUM % 100000) / 10000+ '0'; 
        a[1] = (SUM / 100000) + '0'; 
        T = 6;
        tianjia ();
    }
}

//-----------------------------------------------void tianjia ()新的字符进去------------------------------
void M::tianjia ()
{
    node *head = 0 ,*tail = 0,*newi = 0 ;
    for (int i = 1;  i <= T ; i++)
    {
        newi = new node;
        newi->x = a[i] ;
        if (i == 1)
        {
            head = tail = newi;
        }
        else
        {
            tail->next = newi;
            newi->prior = tail;
            tail = newi;
        }
        if (i == T)
        {
            fleft->next = head;
            head->prior = fleft;
            tail->next = fright;
            fright->prior = tail;
            if (fleft->x == '=')
            {
                Head = head;
            }
            break;
        }
    }
}
//--------------------------------------------------void xiaokuo ()消除  （2115）形式的括号或不含括号的-------------------------
void M:: xiaokuo ()
{
    node *p = Fleft ,*q = Fright;
    if (p != q)                             //消除（3213）这种形式的
    {   
        p->prior->next = p->next;
        p->next->prior = p->prior;
        q->prior->next = q->next;       
        q->next->prior = q->prior;
    }
}
//----------------------------------------------void ok1 ()-用于 *** 和///-----------------------------
int M:: ok1()
{
    Fleftright ();
    node *p = Fleft;                    //判断乘除是否消解完全
    for (p ; p ->x != ')' && p!= 0 ; p = p->next)
    {
        if (p->x == '*' ||p->x == '/' )
        {
            return 1;
        }
        if (p->x == '=')
        {
            return 0;
        }
    }
    return 0;
}

//----------------------------------------------void ok2 ()-用于 +++ 和---  ----------------------------
int M:: ok2()
{
    Fleftright ();
    node *p = Fleft;
    for (p ;  p ->x != ')'  && p!= 0 ; p = p->next)
    {
        if (p->x == '+' ||p->x == '-' )
        {
            return 1;
        }
        if (p->x == '=')
        {
            return 0;
        }
    }
    return 0;
}


//-----------------------------------------------void show ()输出数组的内容-------------------------------
void M:: show ()
{
    node *p =   Head;
    cout<<"结果：";
    for (p ;p != 0 && p ->x != '='; p = p->next)
    {
        cout<<p->x;
    }
    cout<<endl;
}

//------------------------------------------------------void    xxx1 ()--------------------------
void M::XXX1 ()
{
    int x , y , z ;
    while (x = pankong())       //循环处理括号(括号消除完？)
    {
        while (y = ok1())                   //循环处理括号里的乘除
        {
            Fleftright ();              //找到第一个含有右括号的节点地址与其对应的含有左括号的节点地址        
            y = ok1 ();                  //确定是否含有乘除？？
            if ( y == 0 )
                break;
            GetLeftsum1 ();                 //用于 * /，左边字符转化成整数型     找到第一个乘除左边的数值
            GetRightsum1 ();                //用于 * /，右边的字符转化成整数型        找到第一个乘除右边的数值
            jiSUM1 ();                  //用于 * /，计算两边的乘或者除过程
            xiSUM ();                   //用于 * /，整数型转化成字符型       添加到链中，含有tianjia(); 乘或除减少一个
            y = ok1 ();                  //确定消除后是否还含有乘除
        }

        while ( z= ok2 () )         //循环处理括号里的加减（加减消除完？）
        {
            Fleftright ();              //找到第一个含有右括号的节点地址与其对应的含有左括号的节点地址    
            y = ok2 ();                  //确定是否含有+  -
            if ( y == 0 )
                break;
            GetLeftsum2 ();                 //用于 +  -，左边字符转化成整数型        找到第一个+ -左边的数值
            GetRightsum2 ();                //用于+  -，右边的字符转化成整数型        找到第一个+ -右边的数值
            jiSUM2 ();                  //用于 +  -，计算两边的乘或者除过程
            xiSUM ();                   //用于 +  -，整数型转化成字符型       添加到链中，含有tianjia(); +  - 减少一个
            z = ok2 ();                  //确定消除后是否还含有 +   -
        }
        xiaokuo ();         //消除括号（15315），一组括号！！！
        x = pankong ();         //括号是否消除完毕
    }
}

//------------------------------------------------------void    xxx2 ()--------------------------
void M::XXX2 ()
{
    Fleft = Fright = Head;
    int y = ok1 ();                  //确定是否含有乘除？？
    while ( y != 0 )
    {
        GetLeftsum1 ();                 //用于 * /，左边字符转化成整数型     找到第一个乘除左边的数值
        GetRightsum1 ();                //用于 * /，右边的字符转化成整数型        找到第一个乘除右边的数值
        jiSUM1 ();                  //用于 * /，计算两边的乘或者除过程
        xiSUM ();                   //用于 * /，整数型转化成字符型       添加到链中，含有tianjia(); 乘或除减少一个
        y = ok1 ();                  //确定消除后是否还含有乘除
    }
    int z = ok2 ();
    while (z != 0)
    {   
        GetLeftsum2 ();                 //用于+ ， -左边字符转化成整数型     找到第一个乘除左边的数值
        GetRightsum2 ();                //用于 + ， -右边的字符转化成整数型       找到第一个乘除右边的数值
        jiSUM2 ();                  //用于+ ， -计算两边的乘或者除过程
        xiSUM ();                   //用于+ ， -整数型转化成字符型       添加到链中，含有tianjia(); 乘或除减少一个
        z = ok2 ();                  //确定消除后是否还含有乘除
    }
    show ();
}
//------------------------------------------------主函数--------------------------------------------------------
int main()
{
    while (1)
    {
        cout<<"输入计算式子：";
        M m;
        m.create ();
        if ( m.pankong () )
        {
            m.XXX1 ();
            m.XXX2 ();
        }
        else
        {
            m.XXX2 ();
        }
    }

    system("pause");
}

这里写图片描述

wenpu_Di
关注
专栏目录
实现计算器
sokoooo的博客
08-20 1407
一、实现计算器 传入一个字符串，含多位数整数，不含有小数，含有加减乘除其中符号； 二、实现思路 1.中缀转后缀（2－5）＋2＊3一个符号栈和一个链表 1）当遇到符号时：若符号栈为空、栈顶符号为左括号＇(＇、栈顶符号优先级小于等于当前符号优先级时直接入栈；否则进行循环将符号栈的运算符压入链表，直到遇到上面三种情况的否定时停止； ...
C++链表实现一元多项式（加法、减法、乘法）
weixin_43200943的博客
05-21 1344
C++链表实现一元多项式（加法、减法、乘法）
基于循环双向链表的大整数计算器c++实现
11-19
包含链表的基本操作，能够实现多数位的大整数计算，以及十进制数和二进制数的相互转换。
运用链表写的计算器
qq_41668545的博客
02-06 707
#include #include "LinkStack.h" int Priority(char ch) { switch (ch) { case '(': return 3; case '*': case '/': return 2; case '+': case '-': return 1; default: return 0; } }
c语言链表实现简单计算器,链表与栈的典型应用——简单计算器的实现
weixin_30621659的博客
05-23 346
(点击上方公众号，可快速关注)来源：ifndef链接：http://blog.chinaunix.net/uid-28852942-id-3956131.html先来看一个粗糙的简单计算器的实现。他只支持加减乘除，并且一次只能对两个小于10的正整数做一次运算 这是一个粗糙的实现，但是但是仍旧有一些要点体现在上面，比如对 表达式的分析中使用了while(str[i] && str[...
用链表写一个简单计算器
qq_33903332的博客
03-18 1304
问题描述：假设计算器只能进行加减乘除运算，运算数和结果都是整数。 输入样例：1+12/2*3-12= 输出样例：7 思路：1.先将用户输入全部作为字符串存入一个链表中，再将此链表中的数字字符转换为数字，同运算符一起，存入另一个链表中。 2.遍历链表，先乘除后加减。 实现：1.存储用户输入的字符 typedef struct ch{//将用户的输入全部做为字符串存储到此链表中 int ch; struct ch *next; }Char; 2.输入字符，存入链表： char ch; Char *h
Java用链表实现的计算器程序.rar_JAVA计算器链表_计算器链表
09-20
在这个场景下，我们讨论的是一个基于链表实现的计算器程序。链表是一种非常重要的数据结构，它允许我们在内存中动态地存储和管理数据，与数组相比，链表在插入和删除操作上具有更高的效率。 链表的基本思想是通过...
大数计算器_动态链表.zip_c++计算器 链表_大数计算器_大数计算器；动态链表
最新发布
09-23
在本文中，我们将深入探讨如何使用C++编程语言来实现一个大数计算器，特别是通过动态链表来处理大数的四则运算。动态链表是一种数据结构，它允许我们在运行时根据需要添加或删除节点，这使得它们非常适合处理不确定...
数据结构课程设计—用链表实现一元多项式计算器
07-31
用链表实现一元多项式计算器 用链表实现一元多项式计算器 用链表实现一元多项式计算器
数据结构实现计算器 （完整，代码程序）
10-10
数据结构，计算器，非常好，适合学习，进步等等！
用双向链表写的计算器源码
05-29
这段代码包含了简单链表向复合链表的转换，运算符号的关联规则挖掘以及算式填充规则、算式语法正确与否的语法判断
【译】2019年JavaScript中的计算机科学：链表
weixin_34061555的博客
01-24 112
原文地址：Computer science in JavaScript 2019: Linked list 原文作者：Nicholas C. Zakas 早在2009年，我就挑战自己一年内坚持每周写一篇博客文章。我曾经读到过，坚持发表文章是为博客带来流量的最好的方法。基于我的所有文章的理念，一周发表一篇文章看起来是一个很实际的目标，而事实上我缺少了博客文章的52个理念。（译者注：不太清楚这...
多项式计算器 java_链表一元多项式计算器的实现(Java语言描述)
weixin_33470084的博客
02-12 287
链表的经典应用，程序在多项式相加同类项合并还有小的瑕疵，有待改进。代码如下：package 一元多项式计算器;public class PolyNode {private double a;private int i;PolyNode next;public PolyNode(double a,int i){this.a=a;this.i=i;this.next=null;}public Poly...
计算机算法Day2 ---- 基本数据结构（链表）
Travrller的博客
10-08 133
链表 看图说话： 链表又称链式存储结构，顾名思义就是将一个一个单独的数据节点用一条链子将其串起来，从而形成一个整体；其中数据节点在c++中可以将其描述为struct（class也可以），其中包含有数据域和指针域；链子在c++中就是指针； 链表的好处：对于链子来说，我想串连那块内存就串连那块内存（自己的内存空间），不用受物理的约束（不像数组一样，其内存空间必须连续分配），如果条件允许，我可以一直无限的增加；对于数据节点的删除来说就更加简单了，我不想要你就把你从链子上去掉就可以了（数组的删除不仅需要将数据删
计算机考研常用算法分享(二) 链表
一条菜鸟鱼的博客
11-24 444
二 、单链表有关算法 数据结构 typedef struct LNode{ ElemType data; struct LNode * next; }LNode,*LinkList; 1、头插法建立带头结点的单链表 LNode * createList(int a[],int n) { LNode * head,*s; int i; head = (LNode *)malloc(sizeof(LNode)); if(head->next == NULL)
计算机原理之c语言实现链表
jiahangLee的博客
11-06 381
#include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node * next; }; //建立只含头结点的空链表 struct Node * create_list() { struct Node * head = NULL; head =
计算机考研数据结构--链表部分
yuanwa0969的博客
01-03 367
计算机考研数据结构–链表部分 1、顺序表中删除第i个元素； #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; typedef struct SeqList{ int *arr; int arr_length; }SeqList; int main(){ int arr[10]={1,2,3,4,5,6,7,8,9,10}; SeqList l; ...
链表计算器c语言,使用链表栈实现计算器（+-*/）
weixin_35859737的博客
05-25 283
package 数据结构;import java.util.regex.Pattern;/*** @program: java_每天一题* @description: 使用单链表实现栈* 使用栈实现计算器：1，使用一个index遍历运算表达式字符串* 2，如果是数字，存入数字栈* ...
大一作业：高精度计算器链表实现与功能概述
这个结构体用于实现链表的节点。 2. **函数zhengshu(char*& s)**: 这是一个字符串处理函数，接收一个指向字符数组`s`的指针，用于将连续的三个字符转换为整数。它首先创建临时字符数组`ps`和`pc`，然后遍历`s`直到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值