方程求解给定变量的方程组。支持多项式方程以及含有指数，对数和三角函数的方程。方程计算器可以找到方程的数值解和准确解。方程的解是简化的，所以它可能与你所期望的形式不同。支持复杂的解和复杂的方程组,支持复变函数。

方程计算器如何在线使用

通常我们买的学生用计算器是不能直接计算一元二次方程，一元三次方程的，但是在网上我们却能方便准确的计算出来，而且不用下载就可直接使用的哦…

对于一元一次，一元二次方程，我们可以进入此网址http://www.jiefangcheng.net/，或者输入“在线解方程”即可，界面如下，下侧有使用须知，很简单方便，下面举个简单例子介绍怎么使用。

在框里输入2x+8=20，点击“点我解方程”，计算步骤和结果就在下方显示了,同样输入2X^2+8=26，得出结果是±3。注意“^”是英文状态下按shift+6打出来的。

当然也可以输入2 x^2+x+8 = 18带两个X比较复杂点的式子，总之是很方便使用的。

类似这样的在线计算一元一次，一元二次方程的网站有很多，如：计算器在线网，这里你不用输入x，只需要在前边输入系数即可，相比来说这种方法更简单。那么我们看到这两个工具的计算结果是一样的。

下边再介绍个复杂一些的一元三次方程的计算，叫九九参考计算网，网址如下：http://www.99cankao.com/algebra/cubic-equation.php，界面如下，方法和上一个的基本一样。下边我们来举个例子，我们在4个空白框里分别输入1，看到结果如下，很神奇吧！

其实学生用的计算器的计算也可以在网上在线计算的，网址如下：http://www.jisuanqinet.com/shuxue/bangbang.html，界面简单清晰，相信您也会喜欢的！

/**

完成多项式的计算器，可以进行多项式的加法，减法，乘法三种运算。

*/

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

import java.util.Stack;

public class ExpressionMain {

public static void main(String[] args) {

expressionCalculator();

}

private static void expressionCalculator() {

System.out.println("This is a polynomials program.\n" +

"Please enter a valid command:\n" +

"[?] Read a Polynomial.\n" +

"[=] Return a Polynomial.\n" +

"[+] Sum two Polynomial.\n" +

"[-] Difference two Polynomial。 \n" +

"[*] Mult one Polynomial with a term Polynomial.\n" +

"[Q] Quit.\n");

Scanner scanner = new Scanner(System.in);

boolean isTheWorldAlive = true;

Stack stack = new Stack();

while (isTheWorldAlive) {

System.out.println("Select command and presss :");

String command = scanner.next();

if ("?".equals(command)) {

boolean isCurrentExpressionInProgress = true;

Term current = new Term();

boolean firstTime = true;

while (isCurrentExpressionInProgress) {

System.out.println("coefficient?");

int xishu = scanner.nextInt();

if (xishu != 0) {

System.out.println("exponent?");

int zhishu = scanner.nextInt();

if (zhishu != 0) {

if(firstTime){

current.setXishu(xishu);

current.setZhishu(zhishu);

firstTime = false;

}else{

Term temp = current;

while(temp.next != null){

temp = temp.next;

}

temp.next = new Term(xishu, zhishu);

}

} else {

System.out.println("The following has been pushed to Stack:");

System.out.println(current.toString());

stack.push(current);

isCurrentExpressionInProgress = false;

}

} else {

System.out.println("The following has been pushed to Stack:");

System.out.println(current.toString());

stack.push(current);

isCurrentExpressionInProgress = false;

}

}

} else if("+".equals(command)){

System.out.println(Expression.add(stack.pop(), stack.pop()));

}else if("-".equals(command)){

System.out.println(Expression.minus(stack.pop(), stack.pop()));

}else if("*".equals(command)){

System.out.println(Expression.mutiple(stack.pop(), stack.pop()));

}

else if ("Q".equalsIgnoreCase(command)) {

isTheWorldAlive = false;

}

}

}

}

class Term {

private int xishu;

private int zhishu;

Term next = null;

Term(){}

Term(int xishu, int zhishu){

this.xishu = xishu;

this.zhishu = zhishu;

this.next = null;

}

public int getXishu() {

return xishu;

}

public void setXishu(int xishu) {

this.xishu = xishu;

}

public int getZhishu() {

return zhishu;

}

public void setZhishu(int zhishu) {

this.zhishu = zhishu;

}

public String toString(){

String toString = xishu+"X^"+zhishu;

Term term = this.next;

while (term != null){

int nextXishu = term.getXishu();

toString = toString + ((nextXishu>0)?"+"+nextXishu:nextXishu)+"X^"+term.getZhishu();

term = term.next;

}

return toString;

}

}

class Expression {

public static Term add(Term t1, Term t2){

if(t1 == null){

return t2;

}else if(t2 == null){

return t1;

}else{

Term term = new Term();

if(t1.getZhishu() > t2.getZhishu()){

term.setZhishu(t1.getZhishu());

term.setXishu(t1.getXishu());

t1 = t1.next;

}else if(t1.getZhishu() == t2.getZhishu()){

term.setZhishu(t1.getZhishu());

term.setXishu(t1.getXishu() + t2.getXishu());

t1 = t1.next;

t2 = t2.next;

}else{

term.setZhishu(t2.getZhishu());

term.setXishu(t2.getXishu());

t2 = t2.next;

}

term.next = add(t1, t2);

return term;

}

}

public static Term minus(Term t1, Term t2){

if(t1 == null){

return t2;

}else if(t2 == null){

return t1;

}else{

Term term = new Term();

if(t1.getZhishu() > t2.getZhishu()){

term.setZhishu(t1.getZhishu());

term.setXishu(t1.getXishu());

t1 = t1.next;

}else if(t1.getZhishu() == t2.getZhishu()){

term.setZhishu(t1.getZhishu());

term.setXishu(t2.getXishu() - t1.getXishu());

t1 = t1.next;

t2 = t2.next;

}else{

term.setZhishu(t2.getZhishu());

term.setXishu(t2.getXishu() * -1);

t2 = t2.next;

}

term.next = minus(t1, t2);

return term;

}

}

public static Term mutiple(Term t1, Term t2){

Term temTerm;

if(t1.getXishu() < t2.getXishu()){

temTerm = t1;

t1 = t2;

t2 = temTerm;

}

List expressions = new ArrayList();

expressions.add(mutipleSingleTermToWholeTerm(t1, t2));

while (t2.next != null){

t2 = t2.next;

expressions.add(mutipleSingleTermToWholeTerm(t1, t2));

}

Term term = expressions.get(0);

for(int i=1; i

term = add(term, expressions.get(i));

}

return term;

}

private static Term mutipleSingleTermToWholeTerm(Term t1, Term t2){

Term term = new Term();

term.setZhishu(t1.getZhishu() + t2.getZhishu());

term.setXishu(t1.getXishu() * t2.getXishu());

while (t1.next != null){

t1 = t1.next;

term.next = mutipleSingleTermToWholeTerm(t1, t2);

}

return term;

}

}

//运行效果：(展示实现两个多项式的加法)