C#一元一次算法求解

已于 2022-08-24 15:00:16 修改
阅读量1.4k 收藏 7
点赞数 3
分类专栏： 简易算法 c# 文章标签： c# 开发语言
于 2022-05-12 13:53:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LYXtosee/article/details/123701467
版权

一元一次方程解在生活中的做法大多是一下几步↓

举例：5x+6=7x+2

1.换位（5x-7x=2-6）

2.计算（-2x = -4）

3.返回结果（x = 2）

在编程中，我们要实现一元一次方程解也是以下几步↓

1.分割字符串整合成list类型的数据（["5x","+","6"……]）

2.将所有含x的数放在一个list列表里

3.将除=以外所有数字放在另一个列表里

4.去掉x

5.计算

6.返回后的结果相除

7.返回

几个重要思路↓

1.分割时其实主要就是拿一个数作为下标，每经过+-*/=就将前面的数（where下标）和后面的数放在一起也就成了这次要分割的数，直到最后把最后一次的那个数也给加进去就可以了

2.通常我们说的移位在这里其实就是将x所在的数和普通数字进行分类，所以只要设置两个列表即可实现移位的作用

3.计算方面其实我们通常做的加减法也就是第一项和第三项对第二项进行加减法，如1+2其实就是第一项（1）与第三项（2）中间为加法（第二项）得出来的结果（3），长式也是这样，只需要添加一个循环即可

4.当然，如果第一项是+-*/时，其实只需要在列表前面加个0就行（加个0对此式不影响）

这样就可以走完全部流程了！

接下来我们就给这个流程提供必要的函数算法

1.添加包

using System.Collections.Generic;

2.分割算法

        public static List<string> sp(string get)
        {
            char[] ge = get.ToCharArray();
            int where = 0;//当前的下标
            List<string> re = new List<string>();
            string a = string.Empty;
            for(int i =0;i<ge.Length;i++)
            {
                if (ge[i] == '+' || ge[i] == '-' || ge[i] == '*' || ge[i] == '/' || ge[i] == '=')
                {
                    for (int j = where; j < i; j++)
                    {
                        a += ge[j];
                    }
                    re.Add(a);
                    switch (get[i])
                    {
                        case '+': re.Add("+"); break;
                        case '-': re.Add("-"); break;
                        case '*': re.Add("*"); break;
                        case '/': re.Add("/"); break;
                        case '=': re.Add("="); break;
                    }
                    where = i + 1;
                    a = string.Empty;
                }
            }
            for(int k = where; k < ge.Length; k++)
            {
                a += ge[k];
            }
            re.Add(a);
            return re;
        }

3.整合方面

        public static List<string> tidyleft(List<string> get)
        {
            List<string> newget = new List<string>();
            for(int i = 0; i < get.Count; i++)
            {
                if (get[i] == "+" || get[i] == "-" || get[i] == "*" || get[i] == "/")
                {
                    newget.Add(get[i]);
                }
                else
                {
                    if(get[i] == "x")
                    {
                        newget.Add("1");
                    }
                    else
                    {
                        newget.Add(get[i].Substring(0, get[i].Length - 1));
                    }
                }
            }
            return newget;
        }

4.计算方面

  ①检验块

        public static bool have(List<string> get)
        {
            bool h = false;
            for (int i = 0; i < get.Count; i++)
            {
                if (get[i] == "*" || get[i] == "/")
                {
                    h = true;
                    return h;
                }
            }
            return h;
        }

  ②计算快

        public static double calulater(List<string> get, bool hav)
        {
            int i = 0;
            double c = 0;//计算结果
            bool h;
            if(get[0] == "+" || get[0] == "-")
            {
                get.Insert(0, "0");
            }
            if (hav)
            {
                while (true)
                {
                    i++;
                    if (get[i] == "*")
                    {
                        c = int.Parse(get[i - 1]) * int.Parse(get[i + 1]);
                        get[i - 1] = Convert.ToString(c);
                        get.RemoveAt(i);
                        get.RemoveAt(i);
                        i = 0;
                    }
                    else if (get[i] == "/")
                    {
                        if (int.Parse(get[i - 1]) % int.Parse(get[i + 1]) == 0)
                        {
                            c = int.Parse(get[i - 1]) / int.Parse(get[i + 1]);
                            get[i - 1] = Convert.ToString(c);
                            get.RemoveAt(i);
                            get.RemoveAt(i);
                            i = 0;
                        }
                        else
                        {
                            c = double.Parse(get[i - 1]) / double.Parse(get[i + 1]);
                            get[i - 1] = Convert.ToString(c);
                            get.RemoveAt(i);
                            get.RemoveAt(i);
                            i = 0;
                        }
                    }
                    h = have(get);
                    if (!h)
                    {
                        break;
                    }
                    c = 0;
                }
                c = 0;
            }
            if (get.Count != 1)
            {
                while (true)
                {
                    if (get[1] == "+")
                    {
                        c = int.Parse(get[0]) + int.Parse(get[2]);
                        get[0] = Convert.ToString(c);
                        get.RemoveAt(1);
                        get.RemoveAt(1);
                    }
                    else if (get[1] == "-")
                    {
                        c = int.Parse(get[0]) - int.Parse(get[2]);
                        get[0] = Convert.ToString(c);
                        get.RemoveAt(1);
                        get.RemoveAt(1);
                    }
                    c = 0;
                    if (get.Count == 1)
                    {
                        break;
                    }
                }
            }
            return int.Parse(get[0]);
        }

完成以上方法后，我们就可以编写主程序了！！！

主程序其实很简单，只要把以上方法调用后就可以完成了

        public static double Univariate_equation(string input)
        {
            List<string> finalget = new List<string>();
            finalget = sp(input);
            int equal = finalget.IndexOf("=");
            string num = string.Empty;
            List<string> left = new List<string>();
            List<string> right = new List<string>();
            for(int i = 0; i < finalget.Count; i++)
            {
                if(i == equal)
                {
                    continue;
                }
                if (finalget[i].Contains("x"))
                {
                    if (i < equal)
                    {
                        if(i == 0)
                        {
                            left.Add(finalget[i]);
                        }
                        else
                        {
                            left.Add(finalget[i - 1]);
                            left.Add(finalget[i]);
                        }
                    }
                    else
                    {
                        if (i == equal+1)
                        {
                            left.Add("-");
                            left.Add(finalget[i]);
                        }
                        else
                        {
                            switch(finalget[i - 1])
                            {
                                case "+": left.Add("-");break;
                                case "-": left.Add("+"); break;
                                case "*": left.Add("/"); break;
                                case "/": left.Add("*"); break;
                            }
                            left.Add(finalget[i]);
                        }
                    }
                }
                else
                {
                    if (finalget[i] != "+" && finalget[i] != "-" && finalget[i] != "*" && finalget[i] != "/")
                    {
                        if (i < equal)
                        {
                            if (i > 0)
                            {
                                switch (finalget[i - 1])
                                {
                                    case "+": right.Add("-"); break;
                                    case "-": right.Add("+"); break;
                                    case "*": right.Add("/"); break;
                                    case "/": right.Add("*"); break;
                                }
                                right.Add(finalget[i]);
                            }
                            else
                            {
                                right.Add("-");
                                right.Add(finalget[i]);
                            }
                        }
                        else
                        {
                            if (i == equal + 1)
                            {
                                right.Add("+");
                                right.Add(finalget[i]);
                            }
                            else
                            {
                                right.Add(finalget[i - 1]);
                                right.Add(finalget[i]);
                            }
                        }
                    }
                }
            }
            left = tidyleft(left);
            bool h;
            h = have(left);
            double le = calulater(left, h);
            h = have(right);
            double ri = calulater(right, h);
            double re = ri / le;
            return re;
        }

最后返回的那个double值就是最后算出来的结果

测试↓

但这种做法也有一下缺点

1.不支持括号（后面可以写相关算法）

2.有点慢（十几毫秒，但有可能是cpu的问题，看情况）

3.可能不是最快的算法

4.只支持x为未知数的，但可以在源代码里改

所以以上就是文章的全部内容，若有问题，请在下方评论区回复，谢谢！

LYXhw
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用C#解决二元一次方程问题
HongfeiAn
04-03 6540
二元一次方程式 ax+by+c=0（a、b≠0） 通解 首先判断b*b-4*a*c是否大于0，如果小于零，则无解 如果大于0， 假设方程解为x1，x2 x1=-b+根号下b*b-4*a*c/2*a x2=-b-根号下b*b-4*a*c/2*a 使用代码表示 double a; double b; double c; Console.WriteLine("请输入三个数的值："); a = Conv...
C#实现的一元四次方程求解源代码
06-02
本篇主要探讨的是如何使用C#语言来实现一元四次方程的求解。一元四次方程指的是形如ax^4 + bx^3 + cx^2 + dx + e = 0的方程，其中a、b、c、d和e为常数，且a≠0。四次方程可能有四个不同的实根，两个不同实根，一个重...
7-93 解一元一次方程
-
10-18 350
请编写程序，解一元一次方程，a**x+b=0。一元一次方程求解公式为：x=−a**b⋄a\=0, 方程有唯一解，输出解；⋄a=0,b\=0, 方程无解，输出⋄a=0,b=0, 则方程有无穷多解，输出程序中，任何变量的绝对值只要小于10−7,就认为该变量的值为0；否则为非0值。
C#--解方程组之Seidel迭代法
DX奥特曼的博客
05-06 2009
简介高斯-赛德尔迭代法是解线性方程组的常用迭代法之一，设线性方程组为高斯-赛德尔迭代法的迭代公式为当然，此处假定 ，在很多情况下，它比简单迭代法收敛快，它和简单迭代法的不同点在于计算 时，利用了刚刚迭代出的的值，当系数矩阵 A 严格对角占优或对称正定时，高斯-赛德尔迭代法必收敛。迭代公式的实现 public void Calcu6() { int count...
c#实现一元二次方程求解器示例分享
09-04
总之，这个C#示例提供了一个基础的、只处理实数解的一元二次方程求解器，它利用了Windows Forms界面与用户交互，并通过简单的算法实现了方程求解。为了增强功能和实用性，可以考虑添加错误处理、输入验证以及支持...
C#Windows窗体一元二次方程求解程序
05-24
在C#编程环境中，开发一个Windows窗体应用来求解一元二次方程是一个常见的实践项目，这有助于理解和掌握C#的基本语法、Windows Forms界面设计以及数学算法的应用。以下将详细解析这一主题。 一元二次方程的标准形式...
四元一次方程组解决方案C#源码
10-12
四元一次方程组解决方案C#源码
C#中字符串转换为计算公式-并进行计算的方法(自定义公式的计算)
04-05
C#中字符串转换为计算公式-并进行计算的方法(自定义公式的计算)
C#多功能计算器(含源码)
07-11
环境：VS2010 C# Winform 说明：C#实现的计算器，可以计算N元一次方程、常用表达式等，可添加自定义函数；包含源码； 使用： （1）计算表达式： 输入：324-sin(2200)+243 解答：result=566.225994785114 （2）计算N元一次方程： 输入：xx23+24=sin(99)*yy yy = 12*xx23 解答：xx23 = -1.84750650369158 yy = -22.170078044299
C# 解一元三次方程
05-07
1. 首先，我们进行一次线性变换，将方程转换为标准形式：`x³ + px + q = 0`，这可以通过移项和除以a来完成。 2. 然后，使用盛金公式进行进一步变换，得到两个新的二次方程：`u² - uv + v² = -q/2` 和 `u² + uv +...
求解一元四次方程(vb,vc,c#,excel,html)-16.10.15
10-15
描述中提到的“使用 VC++ 编写一元四次方程求解的核心代码”，表明这个项目涉及到了C++编程，尤其是利用C++来实现四次方程的求解算法。C++是一种面向对象的编程语言，适合开发高效、底层的软件。核心代码可能包括了...
一元一次组求解打包（源码+流程图）
05-22
这里包含的源码+流程图，适合c#程序员了解一下，其中主要是利用了c#list列表分割每一项后挨次计算，与普通的方程解步骤一样，其中也是包含了计算方面的内容，可以单独拎出来做一个计算器（一元一次计算使用到计算器...
HNUST计算机学院23级C语言期中考试 J 题一元一次方程C++版题解
qq_40364729的博客
12-07 1169
编辑人：Alant编辑时间：2023年12月7日。
C# 求三次和非线性方程的根MathNet.RootFinding
最新发布
微小冷的学习笔记
12-20 1423
这些静态类一般提供三种求根方法，分别是FindRoot，FindRootExpand以及TryFindRoot，下表列出这些静态类，以及这些静态类支持哪种求根方案。对于三次方程，RootFinding提供了更加便捷的函数Cubic，其调用方方法非常简单，仍以上述函数。为例，Cubic提供了求实根的函数RealRoots，其输入参数为a0,a1,a2，对应方程。最后只得到一个根，说明另外两个根是复数，Cubic提供了三次复数求解器，示例如下。下面以二分法为例，解读一下这些静态函数的用法。
今日分享C#之解一元二次方程！！！
qq_53940289的博客
07-16 848
double m = 0, n = 0; Console.WriteLine("请输入a的值："); double a = Convert.ToDouble (Console.ReadLine ()); Console.WriteLine("请输入b的值："); double b = Convert.ToDouble(Console.ReadLine()); Console.WriteL..
C#一元二次方程求解
09-16
在C#中，可以使用以下代码来求解一元二次方程： ```csharp using System; class Program { static void Main() { Console.WriteLine("请输入一元二次方程的系数："); Console.Write("请输入a的值："); double a = double.Parse(Console.ReadLine()); Console.Write("请输入b的值："); double b = double.Parse(Console.ReadLine()); Console.Write("请输入c的值："); double c = double.Parse(Console.ReadLine()); double discriminant = b * b - 4 * a * c; if (discriminant > 0) { double x1 = (-b + Math.Sqrt(discriminant)) / (2 * a); double x2 = (-b - Math.Sqrt(discriminant)) / (2 * a); Console.WriteLine("方程有两个实根：x1 = {0}, x2 = {1}", x1, x2); } else if (discriminant == 0) { double x = -b / (2 * a); Console.WriteLine("方程有一个实根：x = {0}", x); } else { Console.WriteLine("方程没有实根"); } } } ``` 请注意，上述代码假设用户输入的方程始终有实根。如果方程没有实根，则需要根据实际需求进行相应的处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值