实现多项式相加或相减

我的多项式相加或相减算法Java实现。

实现多项式相加或相减（Poly1-Ploy2 或 Poly2-Poly1）：符合逻辑是输入方式实现。
教师要求：多项式加法（任意输入两个多项式，实现其加减，多项式的幂次不定）。要求：选用合适的数据结构，实现算法，并将结果输出。

此程序用了一个界面来进行操作，截图如下：

程序如下：

/*
 * fuction:实现多项式相加或相减（Poly1-Ploy2 或 Poly2-Poly1）：符合逻辑是输入方式实现
 * 教师要求：多项式加法（任意输入两个多项式，实现其加减，多项式的幂次不定）。要求：选用合适的数据结构，实现算法，并将结果输出。
 * author:iGeneral
 * date:2013.04.22
 * 
 * idea:分别取出每一个项，再从项中取出系数和幂，添加到链表中
 * 
 * expe:
 *         1.String s="+55";
          int a=Integer.parseInt(s);
          System.out.println(a);
        2.String s="3x^3+2x^2+x^1-4";
          int point=s.indexOf('x', 0);
          System.out.println(point);
          System.out.println(s.charAt(point));
        3.String s="igmhqukq";
          System.out.println(s.substring(0, 8));
          succeed!
        4.String s="111";
          System.out.println(s.length());==3
        5.String s="iGeneral";
          System.out.println(s.substring(0,0));==""
        
 * caution:
 *             1.系数可或幂能是一个需要运算的表达式
 *             2.常数项的位置：最前/中间/最后
 *             3.一次项中没有符号'^'，常数项中没有符号'x' & '^'
 *             4.多项式结束
 *             5.可能存在多个同幂的项
 *             6.实现排除错误输入
 *             7.判断多项式是否为空
 *             8.可能多项式只有一项，而且是常数项-----特殊处理
 *             9.运算结果格式化：去掉式子中的"+0"/"-0"，运算结果有一项时将可能存在的 "+0"->"0"
 */
package part03.chapter10;

import java.awt.Button;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class _1exercise2 extends JFrame implements ActionListener, KeyListener {

    // 定义组件
    // 第一个多项式需要的组件
    JLabel name_poly1;
    JTextField contents_poly1;
    Button clear_poly1;
    JPanel panel_poly1;
    // 第二个多项式需要的组件
    JLabel name_poly2;
    JTextField contents_poly2;
    Button clear_poly2;
    JPanel panel_poly2;
    // 对多项式进行操作需要的组件
    Button addBtn;
    Button one_twoBtn;
    Button two_oneBtn;
    JPanel panel_manager;
    // 显示结果需要的组件
    JLabel result_name;
    JTextField result_contents;
    JPanel panel_result;

    // 重写构造函数：初始化界面和组件
    public _1exercise2() {
        // 对第一个多项式的组件进行初始化
        name_poly1 = new JLabel();
        name_poly1.setText("PolyOne = ");
        contents_poly1 = new JTextField("1-2x+3x^2+4x^3+5x^4", 20);
        contents_poly1.setEditable(true);
        clear_poly1 = new Button("clear");
        panel_poly1 = new JPanel();
        panel_poly1.add(name_poly1);
        panel_poly1.add(contents_poly1);
        panel_poly1.add(clear_poly1);
        // 对 clear_poly1 注册监听
        clear_poly1.addActionListener(this);
        clear_poly1.setActionCommand("clear_poly1");
        // 对 contents_poly1 注册监听
        contents_poly1.addKeyListener(this);
        // 对第二个多项式的组件进行初始化
        name_poly2 = new JLabel();
        name_poly2.setText(" PolyTwo = ");
        contents_poly2 = new JTextField("1+2x+3x^2", 20);
        contents_poly2.setEditable(true);
        clear_poly2 = new Button("clear");
        panel_poly2 = new JPanel();
        panel_poly2.add(name_poly2);
        panel_poly2.add(contents_poly2);
        panel_poly2.add(clear_poly2);
        // 对 clear_poly2 注册监听
        clear_poly2.addActionListener(this);
        clear_poly2.setActionCommand("clear_poly2");
        // 对 contents_poly2 注册监听
        contents_poly2.addKeyListener(this);
        // 对操作的组件进行初始化
        addBtn = new Button("PolyOne + PolyOne");
        one_twoBtn = new Button("PolyOne - PolyOne");
        two_oneBtn = new Button("PolyTwo - PolyOne");
        panel_manager = new JPanel();
        panel_manager.add(addBtn);
        panel_manager.add(one_twoBtn);
        panel_manager.add(two_oneBtn);
        // 注册监听
        addBtn.addActionListener(this);
        addBtn.setActionCommand("addBtn");
        one_twoBtn.addActionListener(this);
        one_twoBtn.setActionCommand("one_twoBtn");
        two_oneBtn.addActionListener(this);
        two_oneBtn.setActionCommand("two_oneBtn");
        // 对显示结果的组件进行初始化
        result_name = new JLabel();
        result_name.setText("result = ");
        result_contents = new JTextField(20);
        result_contents.setEditable(false);
        panel_result = new JPanel();
        panel_result.add(result_name);
        panel_result.add(result_contents);
        // 对窗体进行设置
        this.setLayout(new GridLayout(4, 1));
        this.add(panel_poly1);
        this.add(panel_poly2);
        this.add(panel_manager);
        this.add(panel_result);
        this.setTitle("两个多项式的加减运算");
        BufferedImage image = null;
        try {
            image = ImageIO.read(this.getClass().getResource("/colors.png"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

        }
        this.setIconImage(image);
        this.setSize(400, 300);
        this.setLocation(300, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }

    public static void main(String[] args) {
        _1exercise2 computingTowPolys = new _1exercise2();
    }

    // 判断多项式是否为空
    public boolean isNull() {

        if (contents_poly1.getText().equals("")
                && contents_poly2.getText().equals("")) {
            result_name.setText("result = ");
            result_contents.setText("多项式不能为空！");
            return true;
        }
        if (contents_poly1.getText().equals("")) {
            result_name.setText("result = ");
            result_contents.setText("多项式  PolyOne 不能为空！");
            return true;
        }
        if (contents_poly2.getText().equals("")) {
            result_name.setText("result = ");
            result_contents.setText("多项式 PolyTwo 不能为空！");
            return true;
        }
        return false;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub
        SumTowPolynomial sumTowPolynomial = new SumTowPolynomial();
        // 存放运算结构
        String result = "";
        String poly1 = contents_poly1.getText().toString();
        String poly2 = contents_poly2.getText().toString();
//        if(e.getActionCommand().equals("addBtn")){
//            if (!isNull()) {
//                result = sumTowPolynomial.sum(poly1, poly2, '+');
//                result_contents.setText(result);
//                result_name.setText(addBtn.getLabel().toString() + " = ");
//            }
//        }
        switch (e.getActionCommand()) {
        
        case "addBtn":
            if (!isNull()) {
                result = sumTowPolynomial.sum(poly1, poly2, '+');
                result_contents.setText(result);
                result_name.setText(addBtn.getLabel().toString() + " = ");
            }
            break;
        case "one_twoBtn":
            if (!isNull()) {
                result = sumTowPolynomial.sum(poly1, poly2, '-');
                result_contents.setText(result);
                result_name.setText(one_twoBtn.getLabel().toString() + " = ");
            }
            break;
        case "two_oneBtn":
            if (!isNull()) {
                result = sumTowPolynomial.sum(poly2, poly1, '-');
                result_contents.setText(result);
                result_name.setText(two_oneBtn.getLabel().toString() + " = ");
            }
            break;
        case "clear_poly1":
            contents_poly1.setText("");
            break;
        case "clear_poly2":
            contents_poly2.setText("");
            break;
        default:
            break;
        }
    }

    @Override
    public void keyPressed(KeyEvent e) {
        // TODO Auto-generated method stub
    }

    @Override
    public void keyReleased(KeyEvent e) {
        // TODO Auto-generated method stub
        switch (e.getKeyCode()) {
        case KeyEvent.VK_0:
        case KeyEvent.VK_1:
        case KeyEvent.VK_2:
        case KeyEvent.VK_3:
        case KeyEvent.VK_4:
        case KeyEvent.VK_5:
        case KeyEvent.VK_6:
        case KeyEvent.VK_7:
        case KeyEvent.VK_8:
        case KeyEvent.VK_9:
        case KeyEvent.VK_X:
        case KeyEvent.VK_BACK_SPACE:
        case KeyEvent.VK_SHIFT:
        case KeyEvent.VK_EQUALS:// '='
        case KeyEvent.VK_MINUS:// '-'
            // case KeyEvent.VK_LEFT_PARENTHESIS:// '('
            // case KeyEvent.VK_RIGHT_PARENTHESIS:// ')'
        case KeyEvent.VK_CONTROL:
        case KeyEvent.VK_ENTER:
        case KeyEvent.VK_COPY:
        case KeyEvent.VK_CUT:
        case KeyEvent.VK_PASTE:
        case KeyEvent.VK_HOME:
        case KeyEvent.VK_END:
        case KeyEvent.VK_LEFT:
        case KeyEvent.VK_RIGHT:
        case KeyEvent.VK_PERIOD:// '.'

            break;

        default:
            if (this.getFocusOwner() == contents_poly1) {
                contents_poly1
                        .setText(contents_poly1
                                .getText()
                                .toString()
                                .substring(
                                        0,
                                        contents_poly1.getText().toString()
                                                .length() - 1));
            }
            if (this.getFocusOwner() == contents_poly2) {
                contents_poly2
                        .setText(contents_poly2
                                .getText()
                                .toString()
                                .substring(
                                        0,
                                        contents_poly2.getText().toString()
                                                .length() - 1));
            }
            result_contents.setText("请输入数字,'+','_','x','^'!");
            break;
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {
        // TODO Auto-generated method stub

    }

}

// 多项式的项--类
class Term {
    // 系数
    int coefficient = 0;
    // 幂
    int power = 0;
    // 下一个Term的指针
    Term next = null;

    // 重写构造函数：初始化
    public Term(int coefficient, int power) {
        this.coefficient = coefficient;
        this.power = power;
    }
}

// 多项式--类
class SumTowPolynomial {

    // 格式化多项式成链表形式：使容易处理
    public Term formatPolynomial(String polynomial) {
        // 创建两个指针，用来构建链表
        // 多项式链表头指针（是多项式的第一项）
        Term head = new Term(0, 0);
        // 多项式链表当前指针（是多项式的当前项）
        Term point = new Term(0, 0);
        // 当前项的系数
        int coefficient = 0;
        // 当前项的幂
        int power = 0;
        // 多项式的长度
        int polynomualLenth = polynomial.length();
        // 定义两个下标，来标志多项是中某一项的开始下标和结束下标
        int firstIndex = 0;
        int laterIndex = 0;
        // 定义两个下标，用来标识多项式中某个系数或幂在字符串中的开始下标和结束下标
        // 开始下标
        int beginIndex = 0;
        // 结束下标
        int endIndex = 0;
        // 如果多项式只有一项常数项-----特殊情况特殊处理
        if (polynomial.indexOf('+', 1) == -1
                && polynomial.indexOf('-', 1) == -1
                && polynomial.indexOf('x', 1) == -1) {
            head.coefficient = Integer.parseInt(polynomial);
            head.power = 0;
            return head;
        }
        // 循环取出多项式中的每一项，再从项中取出其系数和幂，添加到链表中
        // 当前项的字符串表示
        String currentTerm = "";
        for (int i = 1; i < polynomualLenth; i++) {// i 从 1 开始--------
            // 遇到 '+' / '-' / "i == polynomualLenth-1---最后一项的结束标识" 表示某一项的结束标识
            if (polynomial.charAt(i) == '+'
                    || (polynomial.charAt(i) == '-' && polynomial.charAt(i - 1) != '^')
                    || i == (polynomualLenth - 1)) {
                if (i != (polynomualLenth - 1)) {
                    laterIndex = i;
                } else {
                    laterIndex = i + 1;
                }
                // 获取某一项
                currentTerm = polynomial.substring(firstIndex, laterIndex);
                firstIndex = i;
                // 判断该项是常数项还是非常数项：不同情况不同处理方案----------注意
                endIndex = currentTerm.indexOf('x');
                // 该项为非常数项（非常数项包括一次项和多次项）的处理方案
                if (endIndex != -1) {
                    beginIndex = 0;
                    // 取出系数
                    // 系数可能为 1 ，存在情况有：-x;+x;+x^2;-x^2;第一项的情况:x;
                    if (currentTerm.substring(beginIndex, endIndex).equals("+")
                            || currentTerm.substring(beginIndex, endIndex)
                                    .equals("-")
                            || currentTerm.substring(beginIndex, endIndex)
                                    .equals("")) {
                        coefficient = 1;
                    } else {
                        coefficient = Integer.parseInt(currentTerm.substring(
                                beginIndex, endIndex));
                    }
                    // 取出幂
                    // 如果该项为多次项
                    if (currentTerm.indexOf('^') != -1) {
                        beginIndex = endIndex + 2;
                        endIndex = currentTerm.length();
                        power = Integer.parseInt(currentTerm.substring(
                                beginIndex, endIndex));
                    } else {// 如果该项为一次项
                        power = 1;
                    }
                    // 该项为常数项的处理方案
                } else {
                    coefficient = Integer.parseInt(currentTerm);
                    power = 0;
                }
                // 将该项的系数和幂添加到链表中
                Term term = new Term(coefficient, power);
                if (head.coefficient != 0) {
                    point.next = term;
                    point = term;
                } else {
                    head = term;
                    point = head;
                }
            }
        }
        return head;
    }

    // 对多项式的幂按非降序排序:冒泡排序
    public Term sortPolynomial(Term head) {
        Term point = head;
        // 计算出链表的长度
        int linkLength = 0;
        while (point != null) {
            linkLength++;
            point = point.next;
        }
        // 重置 point，使其指向链表头 head
        point = head;
        // 用于数据的临时变量
        int temp = 0;
        for (int i = 0; i < (linkLength - 1); i++) {
            for (int j = 0; j < linkLength - i - 1; j++, point = point.next) {
                if (point.power > point.next.power) {
                    // 交换系数
                    temp = point.coefficient;
                    point.coefficient = point.next.coefficient;
                    point.next.coefficient = temp;
                    // 交换幂
                    temp = point.power;
                    point.power = point.next.power;
                    point.next.power = temp;
                }
            }
            // 重置 point 至链表头 head
            point = head;
        }
        // 合并同幂项
        // ----------------------------
        return head;
    }

    // 两个多项式相加
    public String sum(String polynomial1, String polynomial2, char sign) {

        // 判断多项式是否为空
        if (polynomial1.equals("") && polynomial2.equals("")) {
            return "多项式不能为空！";
        }
        if (polynomial1.equals("")) {
            return "多项式 PolyOne 不能为空！";
        }
        if (polynomial2.equals("")) {
            return "多项式 PolyTwo 不能为空！";
        }
        // 对两个多项式进行格式化处理
        Term polynomial_1_head = formatPolynomial(polynomial1);
        Term polynomial_2_head = formatPolynomial(polynomial2);
        // 将第二个多项式与第一个多项式相加：通过判断项的幂来判断是否为同一次项，若是，使其系数相加；若不是，直接将其链接到第一个多项式的链表中
        // 先对两个多项式按多项式的幂按非降序排序
        polynomial_1_head = sortPolynomial(polynomial_1_head);
        polynomial_2_head = sortPolynomial(polynomial_2_head);
        // 两个多项式相加
        // 定义两个指针，指向第一个多项式当前项的前后项
        Term point1 = polynomial_1_head;
        Term prevPoint1 = new Term(0, 0);
        prevPoint1.next = polynomial_1_head;
        // 定义一个指针，指向第二个多项式的当前项
        Term point2 = polynomial_2_head;
        // 将第二个多项式添加到第一个多项式中
        while (point2 != null && point1 != null) {
            if (point2.power == point1.power) {
                // 系数相加
                if (sign == '+') {
                    point1.coefficient += point2.coefficient;
                } else if (sign == '-') {
                    point1.coefficient -= point2.coefficient;
                }
                // point2 指针下移一项, 不移动point1的原因：point2的下一项的幂可能与该 point1
                // 项的幂相等，因为没有对同幂项进行预合并处理
                point2 = point2.next;
            } else if (point2.power > point1.power) {
                point1 = point1.next;
                prevPoint1 = prevPoint1.next;
            } else if (point2.power < point1.power) {
                // 用 point2
                // 的系数和幂创建一个新项，并将其链接到point1与prePoint1中间
                // ------------注意，并不是直接用point2来初始化tempTerm,因为tempTerm.next =
                // point1;会让 point2.next = point1;
                Term tempTerm = new Term(point2.coefficient, point2.power);
                tempTerm.next = point1;
                if (prevPoint1.next != polynomial_1_head) {
                    prevPoint1.next = tempTerm;
                } else {
                    polynomial_1_head = tempTerm;
                    prevPoint1.next = polynomial_1_head;
                }
                prevPoint1 = prevPoint1.next;
                // point2 移动到下一项
                point2 = point2.next;
            }
        }
        // 如果还多项式2中存在幂比多项式1中最大幂还大的项，则将这些项全部添加到多项式1的后面（注意两个多项式都已排序）
        if (point2 != null) {// 从上面的while{}可以判断，该条件语句隐含着 && point1==null
            Term point2_point = point2;
            if (sign == '-') {
                while (point2_point != null) {
                    point2_point.coefficient *= (-1);
                    point2_point = point2_point.next;
                }
            }
            // 注意------此处不能用point1=point2;因为point1==null,已不具有指针性质
            prevPoint1.next = point2;
        }
        // 得到相加后的多项式字符串
        String result = getResult(polynomial_1_head);
        return result;
    }

    // 得到相加后的多项式字符串
    public String getResult(Term polynomial_1_head) {
        String result = "";
        Term point1 = polynomial_1_head;
        while (point1 != null) {
            // 幂大于1或小于0 的输出格式
            if (point1.power > 1 || point1.power < 0) {
                if (point1.coefficient > 0) {
                    if (point1 != polynomial_1_head) {
                        // System.out.print("+" + point1.coefficient + "x^"
                        // + point1.power);
                        result += "+" + point1.coefficient + "x^"
                                + point1.power;
                    } else {
                        // System.out.print(point1.coefficient + "x^"
                        // + point1.power);
                        result += point1.coefficient + "x^" + point1.power;
                    }
                } else if (point1.coefficient < 0) {
                    // System.out.print(point1.coefficient + "x^" +
                    // point1.power);
                    result += point1.coefficient + "x^" + point1.power;
                } else if (point1.coefficient == 0) {
                    result += "+0";
                }
            } else if (point1.power == 1) {// 幂等于1 的输出格式
                if (point1.coefficient > 0) {
                    if (point1 != polynomial_1_head) {
                        // System.out.print("+" + point1.coefficient + "x");
                        result += "+" + point1.coefficient + "x";
                    } else {
                        // System.out.print(point1.coefficient + "x");
                        result += point1.coefficient + "x";
                    }
                } else if (point1.coefficient < 0) {
                    // System.out.print(point1.coefficient + "x");
                    result += point1.coefficient + "x";
                } else if (point1.coefficient == 0) {
                    result += "+0";
                }
            } else if (point1.power == 0) {// 幂等于0 的输出格式
                if (point1.coefficient > 0) {
                    if (point1 != polynomial_1_head) {
                        // System.out.print("+" + point1.coefficient);
                        result += "+" + point1.coefficient;
                    } else {
                        // System.out.print(point1.coefficient);
                        result += point1.coefficient;
                    }
                } else if (point1.coefficient < 0) {
                    // System.out.print(point1.coefficient);
                    result += point1.coefficient;
                } else if (point1.coefficient == 0) {
                    result += "+0";
                }
            }
            point1 = point1.next;
        }
        // 去掉式子中的"+0"/"-0"/将仅有一项时的"+0"->"0"
        if (result.length() != 2) {
            for (int i = 0; i < result.length();) {
                if ((result.charAt(i) == '+' && result.charAt(i + 1) == '0')
                        || (result.charAt(i) == '-' && result.charAt(i + 1) == '0')) {
                    result = result.substring(0, i)
                            + result.substring(i + 2, result.length());
                } else {
                    i++;
                }
            }
        }
        // 不能用else if(){} 因为上面的处理可能使多项式出现下面这种情况
        if (result.equals("+0") || result.equals("")) {
            result = "0";
        }
        // 结果式子可能第一位为'+'号,比如出现这种结果"+3+2x^4",需要将'+'号去掉
        if (result.charAt(0) == '+') {
            result = result.substring(1, result.length());
        }
        return result;
    }
}