Java 关于打印多项式

这是存储和计算输入数多项式的类的一部分 这里是方法

public class Polynomial{
int coef,power;

public Polynomial(int maxPower){
}

public void setTerm(int coefficient, int power) {
    this.coef = coefficient;
    this.power = power;
}

以及主方法中的输入参数

public static void main(String[] args){
    Polynomial q = new Polynomial(2);
    q.setTerm(2, 0);
    q.setTerm(0, 1);
    q.setTerm(3, 2);
    System.out.println(q);
}

有一种toString方法可以打印出多项式，如下所示

public String toString(){
    return 
}

---

我一直遇到这样的问题，setTerm方法只读取最后的输入参数，即q.setTerm（3,2），我认为前两个参数已被替换。我能做什么？

您只存储了一个coef和一个电源。 最简单的方法是将系数数组按幂进行索引

public class Polynomial {

    final int[] coefficients;

    public Polynomial(int maxPower) {
        coefficients = new int[maxPower + 1]; // All zero.
    }

    public void setTerm(int coefficient, int power) {
        coefficients[power] = coefficient;
    }

    @Override
    public String toString() {
        StringBuilder sb = newStringBuilder();
        for (int power = 0; power < coefficients.length; ++power) {
            if (coefficients[power] != 0) {
                if (coefficients[power] > 0 && sb.length() > 0) {
                    sb.append('+');
                }
                sb.append(coefficients[power]);
                if (power > 0) {
                    sb.append('x');
                    if (power > 1) {
                        sb.append('^').append(power);
                    }
                }
            }
        }
        return sb.toString();
    }
}

公共类多项式{
最终int[]系数；
公共多项式（int-maxPower）{
系数=新整数[maxPower+1]；//全部为零。
}
公共空间设定值（整数系数，整数幂）{
系数[功率]=系数；
}
@凌驾
公共字符串toString（）{
StringBuilder sb=newStringBuilder（）；
对于（整数幂=0；幂<系数.length；++幂）{
如果（系数[功率]！=0）{
if（系数[幂]>0&&sb.length（）>0）{
某人附加（“+”）；
}
某人附加（系数[幂]）；
如果（功率>0）{
某人附加（'x'）；
如果（功率>1）{
某人追加（权力）；
}
}
}
}
使某人返回字符串（）；
}
}
因此，在您的示例中，我们必须记住前面看到的术语

我将通过一张地图来做这件事，如下所示

import java.util.HashMap;
import java.util.Map;

/**
 * Created by arunavs on 9/28/16.
 */
public class Polynomial {

    // Key is power, value is coeff.
    private Map<Integer, Integer> powerToCoeffMap = new HashMap<>();

    // Maximal power allowed for polynomial.
    private int maxPower;


    public Polynomial(int maxPower){
        this.maxPower = maxPower;
    }

    public void setTerm(int coefficient, int power) {
        if (power > maxPower) {
           // throw some exception here. 
        }
        powerToCoeffMap.put(power, coefficient);
    }

    // terms may be rearranged in output. 
    public String toString() {
        StringBuilder builder = new StringBuilder();
        powerToCoeffMap.forEach((power, coeff) -> {builder.append(coeff + "x^" + power+ " ");});
        return builder.toString();
     }

        public static void main(String args[]) {
            Polynomial q = new Polynomial(2);
            q.setTerm(2, 0);
            q.setTerm(0, 1);
            q.setTerm(3, 2);
        System.out.println(q);
    }
}

import java.util.HashMap；
导入java.util.Map；
/**
*由arunavs于2016年9月28日创建。
*/
公共类多项式{
//关键是力量，价值是系数。
私有映射powerToCoeffMap=newhashmap（）；
//多项式允许的最大幂。
私有int-maxPower；
公共多项式（int-maxPower）{
this.maxPower=maxPower；
}
公共空间设定值（整数系数，整数幂）{
如果（功率>最大功率）{
//在这里抛出一些异常。
}
powerToCoeffMap.put（功率，系数）；
}
//可以在输出中重新排列术语。
公共字符串toString（）{
StringBuilder=新的StringBuilder（）；
forEach（（power，coeff）->{builder.append（coeff+“x^”+power+”）；}）；
返回builder.toString（）；
}
公共静态void main（字符串参数[]）{
多项式q=新的多项式（2）；
q、 setTerm（2,0）；
q、 setTerm（0,1）；
q、 setTerm（3,2）；
系统输出println（q）；
}
}

输出：2x^0 0x^1 3x^2

我希望这有帮助
 另一种可能的实现方式是同时添加多个术语，如下所示：

package de;

import java.util.TreeMap;

public class Polynomial {
    //Private Fields
    private TreeMap<Integer, Integer> polys = new TreeMap<>();

    public Polynomial() {

    }
    public Polynomial(int... args){
        if(args.length < 2) polys.put(0, args[0]);

        for(int i= 0; i < args.length && i+1 < args.length; i = i+2){
            //                        coeff                      power
        polys.put(Integer.valueOf(args[i+1]), Integer.valueOf(args[i]));
        }
        if((args.length % 2) != 0){
            polys.put(0, args[args.length-1]);
        }
    }
    public void setTerm(int coeff, int power){
        polys.put(Integer.valueOf(power),Integer.valueOf(coeff));
    }

    public void setTerms(int... args){
        if(args.length < 2) polys.put(0, args[0]);

        for(int i= 0; i < args.length && i+1 < args.length; i = i+2){
            //                        coeff                      power
        polys.put(Integer.valueOf(args[i+1]), Integer.valueOf(args[i]));
        }
        if((args.length % 2) != 0){
            polys.put(0, args[args.length-1]);
        }
    }
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        for(Integer key : polys.descendingKeySet()){
            Integer value = polys.get(key);
            if(value == 0) continue;
            if(value > 0 && sb.length() != 0) sb.append("+");

            sb.append(value.toString());
            if(key == 1) sb.append("x");
            if(key > 1) sb.append("x^" + key);

            }
            return sb.toString();
        }


    public static void main(String[] args) {
        Polynomial p = new Polynomial(1, 1, -2, 2, -3, 3, 7, 0);
        p.setTerm(17, 5);
        p.setTerms(23, 4, 0, 6);
        System.out.println(p.toString());
    }
}

package-de；
导入java.util.TreeMap；
公共类多项式{
//私人领域
private TreeMap polys=new TreeMap（）；
公共多项式（）{
}
公共多项式（int…args）{
if（args.length<2）polys.put（0，args[0]）；
对于（int i=0；i0&&sb.length（）！=0）sb.append（“+”）；
sb.append（value.toString（））；
如果（键==1）某人追加（“x”）；
如果（键>1）sb.追加（“x^”+键）；
}
使某人返回字符串（）；
}
公共静态void main（字符串[]args）{
多项式p=新的多项式（1,1，-2,2，-3,3,7,0）；
p、 塞特姆（17,5）；
p、 setTerms（23,4,0,6）；
System.out.println（p.toString（））；
}
}

输出：17x^5+23x^4-3x^3-2x^2+1x+7

它从最高功率到最低功率排序，打印x而不是x^1，不打印x^0。
这不起作用。每次调用setTerm时，都会覆盖旧的设置。我建议您使用系数功率对列表/映射来解决此问题。本质上定义一个类术语，其中包含系数和幂作为成员，以及一个术语列表作为多项式类的成员。@ArunavSanyal:这几乎足以成为一个答案；你应该考虑一下你的评论。Yea，我简化了一点，然后给出了答案，非常感谢大家的帮助。我以前考虑过并尝试过列表，事实上我还在学习，还不熟悉它。很高兴看到java 8解决方案，您可以使用树映射来按电源排序。非常感谢，它真的很有帮助。我正在学习并尝试使用地图。我以前也尝试过使用数组。有一个私人的int terms[]我没有贴出来。我把它和幂和系数搞混了，永远也找不到正确的数组。你的想法很清楚，很有帮助，谢谢！！maxPower的构造函数似乎针对从0到maxPower的幂的数组。其他幂次，负数和更大的幂次是不可能的，而且数组是稀疏的，x^100将需要一个包含101个条目的数组。地图类型的解决方案更通用（而且更间接），但不需要maxPower。我明白你的想法。A.