java算法计算一元一次方程

最新推荐文章于 2022-12-17 15:27:30 发布
最新推荐文章于 2022-12-17 15:27:30 发布
阅读量8k 收藏 15
点赞数 3
分类专栏： 数据结构与算法 文章标签： java算法 java计算一元一次 一元一次方程算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiuLinSmile/article/details/78907930
版权

java算法计算一元一次方程是昨年10月写的了,最近想写写算法就把它整理出来了。

核心思想是将方程转化为：aX+b = cX+d 的形式再进行计算，转化的思想是根据符号的优先级一层一层的分割。分割规则是先把+号能分割完的分割完，再把-号能分割完的分割完，最后分割*/号，不能从括号里面分割。具体过程如下：

方程：-3-12+2*(-7+5x)=-3-4+3*(6x+9)+10*3-20-30，以左边为例：

先根据 + 号 分割，结果为：

左：-3-12                              +                             右： 2*（-7+5x）

左边只能根据 - 号分割，右边根据*号分割

左：左：-3    -    右：12         +                             右： 左：2         *       右：-7+5x

左边，右边都是 aX+b 形式直接计算，-3也是aX+b形式（a=0,b=-3）

左：-15                                  +                             右：-14+10x

最后左侧将转化为：10x-29

完整代码如下：

/**
 * Created by LL on 2016/10/13.
 */
public class yiyuanyicifangcheng {

    public static void main(String[] args) {
        String string="-3-12+2*(-7+5x)=-3-4+3*(6x+9)+10*3-20-30";
        double result = calculate(string);
        System.out.println("计算结果：x = "+result);
    }

    /**
     * 此类方法用于将字符串化为: aX+b 结构，结果返回a,b
     * @param str:需要计算的字符串
     */
    public static Result translate(String str) {
        str=deleteKH(str);
        char[] chars = str.toCharArray();
        //先根据 + 号 将字符串分割完
        for (int i = 0, kuHaoNum = 0; i < chars.length; i++) {
            kuHaoNum = getBracketsNum(kuHaoNum,i,chars);
            if(kuHaoNum==0&&("+".equals(chars[i]+""))){ //括号里面不分割
                String s01=str.substring(0,i);
                String s02=str.substring(i+1, str.length());
                Result result01=getResultFromString(s01);
                Result result02=getResultFromString(s02);
                Result result=new Result();
                result.setA(result01.getA()+result02.getA());
                result.setB(result01.getB()+result02.getB());
                return result;
            }
        }
        //再根据 - 号 将字符串分割完  注意：- 号是从后往前分割
        for (int i=chars.length-1,kuHaoNum=0;i>=0 ;i--) {
            kuHaoNum = getBracketsNum(kuHaoNum,i,chars);
            if(kuHaoNum==0&&("-".equals(chars[i]+""))){ //括号里面不分割
                String s01=str.substring(0,i);
                String s02=str.substring(i+1, str.length());
                Result result01=getResultFromString(s01);
                Result result02=getResultFromString(s02);
                Result result=new Result();
                result.setA(result01.getA()-result02.getA());
                result.setB(result01.getB()-result02.getB());
                return result;
            }
        }
        //最后根据 *，/ 号 将字符串分割
        for(int i=0,kuHaoNum=0;i<chars.length;i++){
            kuHaoNum = getBracketsNum(kuHaoNum,i,chars);
            if(kuHaoNum==0&&("*".equals(chars[i]+"")||"/".equals(chars[i]+""))){ //括号里面不分割
                String s01=str.substring(0, i);
                String fuhao=str.substring(i, i+1);
                String s02=str.substring(i+1, str.length());
                Result result01=getResultFromString(s01);
                Result result02=getResultFromString(s02);
                Result result=new Result();
                if(fuhao.equals("*")){  //因为是一元一次方程  不会出现 （aX+b）*(aX+b)的情况
                    if(result01.getA()!=0){
                        result.setA(result01.getA()*result02.getB());
                        result.setB(result01.getB()*result02.getB());
                    }
                    if(result02.getA()!=0){
                        result.setA(result01.getB()*result02.getA());
                        result.setB(result01.getB()*result02.getB());
                    }
                    if(result01.getA()==0&&result02.getA()==0){
                        result.setA(0.0);
                        result.setB(result01.getB()*result02.getB());
                    }
                }else if(fuhao.equals("/")){
                    result.setA(result01.getA()/result02.getB());
                    result.setB(result01.getB()/result02.getB());
                }
                return  result;
            }
        }
        return  null;
    }


    /**
     * 此类方法用于获取从起始位置到当前位置经历了几个括号
     * @param num:括号数量
     * @param index:字符数组的位置
     * @param chars:字符数组
     */
    public static int getBracketsNum(int num,int index,char[] chars){
        if("(".equals(chars[index]+"")){
            num++;
        }else if(")".equals(chars[index]+"")){
            num--;
        }
        return num;
    }

    /**
     * 此类方法用于将字符串转化为 aX+b 的形式  返回 Result
     * @param str:需要转化的字符串
     */
    public static Result getResultFromString(String str){
        Result result = new Result();
        if(str.equals("")){
            result.setA(0.0);
            result.setB(0.0);
        }else if(isRightString(str)){
            String standString=getStandardFormatString(str);
            standString=deleteKH(standString);
            result.setA(Double.parseDouble(standString.substring(0,standString.indexOf("x"))));
            result.setB(Double.parseDouble(standString.substring(standString.indexOf("x")+1,standString.length())));
        }else if (isNum(str)){
            result.setA(0.0);
            result.setB(Double.parseDouble(str));
        }else{
            result=translate(str);
        }
        return result;
    }

    /**
     * 此类方法用于计算方程
     * @param string:需要计算的方程
     */
    public static double calculate(String string){
        String string01=string.substring(0,string.indexOf("="));
        String string02=string.substring(string.indexOf("=")+1,string.length());
        Result result01=translate(string01);
        Result result02=translate(string02);
        System.out.println("原方程为："+string);
        System.out.println("转化后的标准格式为："+result01.getA()+"x+("+result01.getB()+")="+result02.getA()+"x+("+result02.getB()+")");
        double a1=result01.getA();
        double b1=result01.getB();
        double a2=result02.getA();
        double b2=result02.getB();
        if(a1==a2&&b1!=b2){
            System.out.println("此方程无解");
        }else if(a1==a2&&a1==b2){
            System.out.println("此方程有任意解");
        }else if(a1!=a2){
            return (b2-b1)/(a1-a2);
        }
        return 0.0;
    }

    /**
     * 此类方法用于判断字符串是否是数字
     * @param str:需要判断的字符串
     */
    public static boolean isNum(String str){
        boolean isNum = true;
        try{
            double d = Double.parseDouble(str);
        }catch (Exception e){
            isNum = false;
        }
        return isNum;
    }

    /**
     * 此类方法用于判断字符串是否是类似于  aX+b 格式
     * @param s:需要判断的字符串
     */
    public static boolean isRightString(String s){
        char[] c=s.toCharArray();
        int j=0;
        for(int i=0;i<c.length;i++){
            if("+".equals(c[i]+"")||"-".equals(c[i]+"")){
                j++;
            }
        }
        if(s.contains("x")&&j<=1){
            if(!s.contains("(")){
                return true;
            }else if(s.contains("(")&&s.indexOf("(")==0){
                return true;
            }
        }
        return false;
    }


    /**
     * 此类方法用于将字符串转化为  aX+b 标准格式
     * @param s:需要转化的字符串
     */
    public static String getStandardFormatString(String s){
        char[] c=s.toCharArray();
        int t=0;
        StringBuffer s1=new StringBuffer(s);
        if(s.contains("+")||s.contains("-")){
            for(int i=0;i<c.length;i++){
                if("+".equals(c[i]+"")||"-".equals(c[i]+"")){
                    t=i;//t 用于记住 +,-号的位置
                    break;
                }
            }
            if(s.indexOf("x")<t){
                return s;
            }else{
                String s2=s.substring(0,t);
                String s3=s.substring(t,s.length());
                StringBuffer ss=new StringBuffer(s3);
                ss.append(s2);
                return ss.toString();
            }
        }else{
            return s1.append("+0").toString();
        }
    }

    /**
     * 此类方法用于去掉字符串最外层的括号
     * @param str:需要处理的字符串
     */
    public static String deleteKH(String str){
        if(str.startsWith("(")&&str.endsWith(")")){
            str = str.substring(1, str.length() - 1);
        }
        return str;
    }

    /**
     * 此类定义了  aX+b 结构中的 a和b
     * 注意 这里的a,b可以为负,即aX-b也属于这种结构
     */
    public static class Result{
        double a;
        double b;
        public Result(){
        }
        public Result(double a,double b) {
            this.a=a;
            this.b=b;
        }
        public double getA() {
            return a;
        }
        public double getB() {
            return b;
        }
        public void setA(double a) {
            this.a = a;
        }
        public void setB(double b) {
            this.b = b;
        }
        @Override
        public String toString() {
            return "Result{" +
                    "a=" + a +
                    ", b=" + b +
                    '}';
        }
    }
}

运行结果：

这里写图片描述

solitaryWalker
关注
专栏目录
算法和Java实现解一元一次方程
CyberLynxO的博客
08-14 513
具体来说，我们可以使用公式x = (-by - c) / a来计算x的值，并使用公式y = (-ax - c) / b来计算y的值。首先，我们定义了已知的实数常量a、b和c，并初始化它们的值。总结起来，我们在本文中介绍了一个基于Java的算法，用于解一元一次方程。我们通过利用数学中的线性代数知识，使用简单的公式来计算未知变量的值。在本文中，我们将介绍一个基于Java的算法，并提供相应的源代码。其中，a、b和c是已知的实数常量，而x和y是未知的变量。我们的目标是求解x和y的值。
java计算一元二次方程的根_java基础 --- 求一元二次方程的根（分情况讨论）-Go语言中文社区...
weixin_35097346的博客
02-27 2319
package com.test;//创建一个test包import java.util.Scanner;//导入java.util包中的Scanner类(使用此类可以方便的完成输入流的输入操作)import java.math.BigDecimal;//导入java.math包中的BigDecimal(用来对超过16位有效位的数进行精确的运算)//对一元二次方程中各系数的不同情况作讨论，列出不同...
洛谷 P1022 计算器的改良
sdfzrlt的博客
10-10 1180
模拟
Java 算法 一元一次方程
joreng的博客
03-27 1645
@TOC在这里插入代码片 题目描述 输入一元一次方法的ax+b=0的解。且数据均在double类型以内,且一定有解（保留2位小数） 输入 输入描述: 输入样例: 2 6 输出 输出描述: 输出样例: -3.00 HINT:时间限制：1.0s 内存限制：512.0MB 解题思路 就输入数据后，按运算关系输出就行了。 代码 import java.util.Scanner; public class Main { public static void main(String[] args) {
Java解一元一次方程，一元二次方程，一元三次方程
Along的博客
04-26 2069
/** * @author Along * @desc 一元三次方程，二次方程，和一次方程求解工具类 */ public class EquationCalculation { /* 计算一元三次方程最大实根 * 一元三次方程(ax3+bx2+cx+d＝0)的盛金公式解题法 * 输入：参数a,b,c,d * 1)：当A=B=0时，方程有一个三重实根；...
java 一元一次方程求解_初一数学知识点：一元一次方程
weixin_39928106的博客
11-03 392
01知识框架02知识概念1一元一次方程 只含有一个未知数，并且未知数的次数是1，并且含未知数项的系数不是零的整式方程是一元一次方程。2一元一次方程的标准形式 ax+b=0 x是未知数，a、b是已知数，且a≠03解一元一次方程的步骤  解一元一次方程的一般步骤有：去分母、去括号、移项、合并同类项、系数化为1.具体见下表：4列一元一次方程解应用...
java 一元一次方程求解_一元一次方程解法教学的深思考
weixin_39835117的博客
11-28 914
武海娟：吉林大学附属中学教师，东北师范大学硕士研究生，长春市名师工作室主持人，吉林省教学新秀，长春市首届明星教师、骨干教师、优秀班主任，2015年长春市中考数学命题组成员，中考人才库成员。曾获第七届青年教师全国公开课一等奖，东北地区优质课一等奖第一名，在长春市集体备课中担任主讲，多次为内蒙古、安徽等地国培教师做专题讲座，受到业界好评。方程是数学学习中最为重要的一个内容，它贯穿了整个数学体...
实数一元二次方程求解算法-java代码
最新发布
09-21
实数一元二次方程求解算法--java代码
java 一元三次方程_求解一元三次方程的方法java实现
weixin_32968155的博客
02-19 1280
public double findFS(double a, double b, double c, double d) {double FS = 0;double A, B, C, delta;double x1, x2, x3;A = b * b - 3 * a * c;B = b * c - 9 * a * d;C = c * c - 3 * b * d;delta = B * B - 4 ...
蓝桥杯算法训练 一元三次方程求解java
weixin_43824233的博客
04-21 872
问题描述 　　有形如：ax3+bx2+cx+d=0 这样的一个一元三次方程。给出该方程中各项的系数(a，b，c，d 均为实数)，并约定该方程存在三个不同实根(根的范围在-100至100之间)，且根与根之差的绝对值>=1。要求三个实根。。 输入格式 　　四个实数：a，b，c，d 输出格式 　　由小到大依次在同一行输出这三个实根(根与根之间留有空格)，并精确到小数点后2位 样例输入 1 -5 -...
java解一元二次方程
03-18
java解一元二次方程，swing界面，输入a,b,c三个值解方程
解一元n次方程的java代码
06-07
解一元n次方程，最大公约，最小公倍的计算，java中直接使用
java编写求解一元多次方程的解
04-25
编写求解一元多次方程的解，要求如下： 1）至少包括一元一次、一元二次、一元三次方程 2) 至少设计两个接口 3）必须用到内部类和包 4）写出详细的编译运行过程
java编写一元二次方程
weixin_35750483的博客
12-17 2099
在 Java 中编写一元二次方程的步骤如下： 定义三个变量，分别表示一元二次方程的系数 a、b 和 c。 使用公式计算一元二次方程的两个解，公式如下： x1 = (-b + sqrt(b^2-4ac)) / 2a x2 = (-b - sqrt(b^2-4ac)) / 2a 其中，sqrt 表示平方根。 输出结果。 示例代码如下： import java.lang.Math; pub...
java解一元一次方程
短腿姑娘的博客
04-21 1997
复旦大学上机题（二） 解方程。给定一个字符串，代表一个一元一次方程。如果有解求解，输出格式“x=数字” ，如果解的个数无穷，输出 “infinite solutions”。如果没有解输出“no solution” 字符串长度不超过 256 。 输入格式： 输入一个一元一次方程，未知数用x表示。 输出格式： 输出 “x=数字” 或者 “infinite solutions”或者“no solution” 输入样例： 10x-2x-8=4x+7+x 输出样例：x=5 package cn.l
java 算方程_java算法计算一元一次方程
weixin_39705435的博客
02-12 1202
java算法计算一元一次方程是昨年10月写的了,最近想写写算法就把它整理出来了。核心思想是将方程转化为：aX+b = cX+d 的形式再进行计算，转化的思想是根据符号的优先级一层一层的分割。分割规则是先把+号能分割完的分割完，再把-号能分割完的分割完，最后分割*/号，不能从括号里面分割。具体过程如下：方程：-3-12+2*(-7+5x)=-3-4+3*(6x+9)+10*3-20-30，以左边为例...
java 一元一次方程求解_解一元一次不等式
weixin_39929918的博客
11-09 694
提要运用不等式的基本性质解一元一次不等式的步骤如下：去分母；去括号；移项；合并同类项；系数化为1。特别应当注意，不等式的两边都乘以或除以同一个负数时，不等式的方向必须改变。解不等式时要熟练掌握以上的五步法，又要根据不等式的特征灵活运用方法，使过程简便。解一元一次不等式时，应先观察各项的特征，然后根据其特征选择恰当的方法求解，往往有更简洁的方法。知识全解一．一元一次不等式的概念 一般的，不等式中只含...
java 一元一次方程求解_初一数学半个难点一元一次方程，吃透它等于搞定数学的50%...
weixin_39534321的博客
11-28 205
初一数学半个难点一元一次方程，吃透它等于搞定数学的50%！ 初一的数学基本上没有什么难度，都是初中的基础概念和运算的法则。压轴题和重难点集中在数轴动点和一元一次方程的应用。其中一元一次方程的应用是比较灵活的题型。 一元一次方程比较灵活是因为考察的题型会比较多，其中工程问题、行程问题、分配问题、盈亏问题、积分表问题、电话计费问题、数字问题这7种题型是考察的主流，题目不复杂，但是各类题型涉及数学逻辑比...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值