多项式除法Java实现

MonteCarIo

已于 2022-03-12 10:36:11 修改

阅读量1.1k

点赞数

分类专栏： Java 文章标签： java 开发语言算法

于 2022-03-12 10:33:51 首次发布

本文链接：https://blog.csdn.net/Hami1ton/article/details/123439561

版权

Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

单项式实体类

例如：在 $2x^{2}+1$ 中， $2x^{2}$ 代表一个 PolynomialEntity 类对象

/**
 * 多项式中表示每一项的实体类
 * 例如：2x^2+1 中，2x^2代表一个 PolynomialEntity 类
 */
public class PolynomialEntity {
	
	/**
	 * 系数
	 */
	private FractionEntity coefficient;
	
	/**
	 * 幂
	 */
	private Integer power;
	
	public PolynomialEntity() {
	}
	
	public PolynomialEntity(FractionEntity coefficient, Integer power) {
		this.coefficient = coefficient;
		this.power = power;
	}
	
	public FractionEntity getCoefficient() {
		return coefficient;
	}
	
	public void setCoefficient(FractionEntity coefficient) {
		this.coefficient = coefficient;
	}
	
	public Integer getPower() {
		return power;
	}
	
	public void setPower(Integer power) {
		this.power = power;
	}
	
	/**
	 * 判断系数是否为整数1
	 */
	private int isIntegerOne() {
		if (this.coefficient.getMolecule() % this.coefficient.getDenominator() == 0) {
			//	为整数情况
			if (this.coefficient.getMolecule() / this.coefficient.getDenominator() == 1) {
				return 1;
			} else if (this.coefficient.getMolecule() / this.coefficient.getDenominator() == -1) {
				return -1;
			} else {
				return 0;
			}
		}
		return 0;
	}
	
	@Override
	public String toString() {
		if (isIntegerOne() == 1 && power == 0) {
			return "1";
		} else if (isIntegerOne() == -1 && power == 0) {
			return "-1";
		} else if (isIntegerOne() == 0 && power == 0) {
			return coefficient.toString();
		} else if (isIntegerOne() == 1 && power == 1) {
			return "x";
		} else if (isIntegerOne() == -1 && power == 1) {
			return "-x";
		} else if (isIntegerOne() == 0 && power == 1) {
			return coefficient.toString() + "x";
		} else {
			return coefficient.toString() + "x^" + power;
		}
	}
	
}

分式实体类

/**
 * 分式实体类，例如：1 / 3
 */
public class FractionEntity {
	
	/**
	 * 分子
	 */
	private int molecule;
	/**
	 * 分母
	 */
	private int denominator;
	
	public FractionEntity() {
	}
	
	public FractionEntity(int molecule, int denominator) {
		this.molecule = molecule;
		this.denominator = denominator;
	}
	
	public int getMolecule() {
		return molecule;
	}
	
	public void setMolecule(int molecule) {
		this.molecule = molecule;
	}
	
	public int getDenominator() {
		return denominator;
	}
	
	public void setDenominator(int denominator) {
		this.denominator = denominator;
	}
	
	@Override
	public String toString() {
		return this.molecule % this.denominator == 0 ? Integer.toString(this.molecule / this.denominator) : this.molecule + "/" + this.denominator;
	}
	
}

分式工具类

/**
 * 分式工具类
 */
public class FractionUtil {
	
	/**
	 * 最大公约数方法
	 */
	public static int greatestCommonDivisor(int a, int b) {
		if (a > b) {
			return (a % b == 0) ? b : greatestCommonDivisor(b, a % b);
		}
		return (b % a == 0) ? a : greatestCommonDivisor(a, b % a);
	}
	
	/**
	 * 最小公倍数
	 */
	public static int leastCommonMultiple(int a, int b) {
		return a * b / greatestCommonDivisor(a, b);
	}
	
	/**
	 * 判断一个分式是否为负数
	 */
	public static boolean isMinus(FractionEntity fraction) {
		return fraction.getMolecule() * fraction.getDenominator() < 0;
	}
	
	/**
	 * 分式除法
	 */
	public static FractionEntity division(FractionEntity a, FractionEntity b) {
		// 如果分式为0，则直接返回0
		if (a.getMolecule() == 0 || b.getMolecule() == 0) {
			return new FractionEntity(0, 1);
		}
		// 计算结果
		FractionEntity result = new FractionEntity();
		// 计算
		result.setMolecule(a.getMolecule() * b.getDenominator());
		result.setDenominator(a.getDenominator() * b.getMolecule());
		// 求最大公约数
		int factor = greatestCommonDivisor(Math.abs(result.getMolecule()), Math.abs(result.getDenominator()));
		// 约分
		result.setDenominator(result.getDenominator() / factor);
		result.setMolecule(result.getMolecule() / factor);
		// 返回结果
		return result;
	}
	
	/**
	 * 分式乘法
	 */
	public static FractionEntity multiplication(FractionEntity a, FractionEntity b) {
		// 如果分式为0，则直接返回0
		if (a.getMolecule() == 0 || b.getMolecule() == 0) {
			return new FractionEntity(0, 1);
		}
		// 计算结果
		FractionEntity result = new FractionEntity();
		// 计算
		result.setMolecule(a.getMolecule() * b.getMolecule());
		result.setDenominator(a.getDenominator() * b.getDenominator());
		// 求最大公约数
		int factor = greatestCommonDivisor(Math.abs(result.getMolecule()), Math.abs(result.getDenominator()));
		// 约分
		result.setDenominator(result.getDenominator() / factor);
		result.setMolecule(result.getMolecule() / factor);
		// 返回结果
		return result;
	}
	
	/**
	 * 分式减法
	 */
	public static FractionEntity subtraction(FractionEntity a, FractionEntity b) {
		// 分式减法这儿要分别考虑被减数和减数为0的情况
		if (a.getMolecule() == 0 && b.getMolecule() != 0) {
			b.setMolecule(-1 * b.getMolecule());
			return b;
		} else if (a.getMolecule() != 0 && b.getMolecule() == 0) {
			return a;
		} else if (a.getMolecule() == 0 && b.getMolecule() == 0) {
			return a;
		}
		// 计算结果
		FractionEntity result = new FractionEntity();
		// 通分并计算
		// 两个分数的分母的最小公倍数
		int multiple = leastCommonMultiple(a.getDenominator(), b.getDenominator());
		int temp1 = multiple / a.getDenominator();
		int temp2 = multiple / b.getDenominator();
		// 分子相减
		result.setMolecule(a.getMolecule() * temp1 - b.getMolecule() * temp2);
		// 分母不变
		result.setDenominator(multiple);
		// 约分
		// 不考虑符号
		int factor = greatestCommonDivisor(Math.abs(result.getMolecule()), Math.abs(result.getDenominator()));
		result.setDenominator(result.getDenominator() / factor);
		result.setMolecule(result.getMolecule() / factor);
		// 返回结果
		return result;
	}
	
}

多项式除法主类

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * 多项式除法
 */
public class PolynomialDivision {
	
	/**
	 * 这里采用链表+单项式实体类表示多项式<br/>
	 * 可以使用二维数组，但二维数组较为抽象不易理解
	 */
	public static void main(String[] args) throws Exception {
		
		// 保存被除多项式
		List<PolynomialEntity> polynomial01 = new ArrayList<>();
		// 保存除以的多项式
		List<PolynomialEntity> polynomial02 = new ArrayList<>();
		// 从控制台输入多项式
		Scanner scanner = new Scanner(System.in);
		int index = 0;
		System.out.println(">>>>>>>>>>>>>>>请输入被除多项式（多项式中不要出现多个相同幂的单项式，且多项式按最高次幂依次输入，且只支持整数幂情况）<<<<<<<<<<<<<<<");
		InputPolynomial(polynomial01, scanner, index);
		System.out.println(">>>>>>>>>>>>>>>请输入除以的多项式（多项式中不要出现多个相同幂的单项式，且多项式按最高次幂依次输入，且只支持整数幂情况）<<<<<<<<<<<<<<<");
		InputPolynomial(polynomial02, scanner, index);
		// 执行多项式除法并打印竖式
		// polynomials保存多项式除法中的余式多项式
		List<List<PolynomialEntity>> polynomials = new ArrayList<>();
		// polynomials0保存多项式除法中的中间多项式，即每次除法是跟被除式子做减法的那个多项式
		List<List<PolynomialEntity>> polynomials0 = new ArrayList<>();
		// merchant保存多项式除法的商
		List<PolynomialEntity> merchant = new ArrayList<>();
		// remainder保存多项式除法的余数，也是递归调用中下一次被除多项式
		List<PolynomialEntity> remainder = new ArrayList<>();
		div(polynomial01, polynomial02, polynomials, merchant, remainder, polynomials0);
		System.out.println(">>>>>>>>>>>>>>>最终计算结果<<<<<<<<<<<<<<<");
		OutputPolynomial(polynomial01);
		System.out.print(" / ");
		OutputPolynomial(polynomial02);
		System.out.print(" = ");
		OutputPolynomial(merchant);
		System.out.print("...");
		OutputPolynomial(remainder);
	}
	
	/**
	 * 打印多项式
	 */
	private static void OutputPolynomial(List<PolynomialEntity> polynomial) {
		for (int i = 0; i < polynomial.size(); i++) {
			// 非0单项式
			if (polynomial.get(i).getCoefficient().getMolecule() != 0) {
				// 第一项
				if (i == 0) {
					System.out.print(polynomial.get(i));
				} else {
					// 如果系数为负数
					if (FractionUtil.isMinus(polynomial.get(i).getCoefficient())) {
						System.out.print(polynomial.get(i));
					} else {
						System.out.print("+" + polynomial.get(i));
					}
				}
			}
		}
	}
	
	/**
	 * 多项式除法
	 *
	 * @param polynomial01 被除多项式
	 * @param polynomial02 除以的多项式
	 * @param polynomials  多项式除法中的余式多项式
	 * @param merchant     商
	 * @param remainder    余数，也是递归调用中下一次被除多项式
	 * @param polynomials0 多项式除法中的中间多项式，即每次除法是跟被除式子做减法的那个多项式
	 */
	private static void div(List<PolynomialEntity> polynomial01, List<PolynomialEntity> polynomial02,
							List<List<PolynomialEntity>> polynomials, List<PolynomialEntity> merchant,
							List<PolynomialEntity> remainder, List<List<PolynomialEntity>> polynomials0) throws Exception {
		// 清空余数，因为上次计算过重充当了临时变量
		remainder.clear();
		// 通过递归依次消除被除多项式单项式（从最 高次幂-首个单项式 开始）
		PolynomialEntity firstItem = polynomial01.get(0);
		// 获得本次计算中商的单项式的最高次幂和系数并加入到最终商中
		// 计算系数
		FractionEntity coefficient = FractionUtil.division(firstItem.getCoefficient(), polynomial02.get(0).getCoefficient());
		// 计算幂
		int power = firstItem.getPower() - polynomial02.get(0).getPower();
		// 将计算出的单项式加入到最终商中
		PolynomialEntity temp = new PolynomialEntity(coefficient, power);
		merchant.add(temp);
		// 计算本次计算过程的中间多项式
		List<PolynomialEntity> entity = new ArrayList<>();
		for (PolynomialEntity polynomialEntity : polynomial02) {
			entity.add(new PolynomialEntity(FractionUtil.multiplication(polynomialEntity.getCoefficient(), temp.getCoefficient()), temp.getPower() + polynomialEntity.getPower()));
		}
		// 中间多项式补零
		fillZeroItem(entity);
		// 添加中间多项式
		polynomials0.add(entity);
		// 计算多项式除法中的余式多项式，也是递归调用中下一次被除多项式
		// 从被除多项式的第二项开始做分式减法，因为每次中间计算时总是消掉被除多项式的最高次幂项
		for (int i = 1; i < polynomial01.size(); i++) {
			remainder.add(new PolynomialEntity(FractionUtil.subtraction(polynomial01.get(i).getCoefficient(), entity.get(i).getCoefficient()), polynomial01.get(i).getPower()));
		}
		// 余式多项式补零
		fillZeroItem(remainder);
		// 保存本次计算中的余数
		polynomials.add(remainder);
		if (!remainder.isEmpty() && remainder.get(0).getPower() >= polynomial02.get(0).getPower()) {
			List<PolynomialEntity> list = new ArrayList<>(remainder);
			div(list, polynomial02, polynomials, merchant, remainder, polynomials0);
		}
	}
	
	/**
	 * 输入多项式 - 注意本方法不处理多项式出现多个相同次幂的单项式情况<br/>
	 * 同时，假设输入的多项式均为按最高次幂降序输入（即此处不进行排序）
	 *
	 * @param polynomial 代表一个多项式
	 * @param scanner    输入流
	 * @param index      代表多项式中的第 index 个单项式
	 */
	private static void InputPolynomial(List<PolynomialEntity> polynomial, Scanner scanner, int index) throws Exception {
		do {
			PolynomialEntity polynomialEntity = new PolynomialEntity();
			System.out.print("请输入多项式第 " + index + 1 + " 项(从左往右)的系数（分数格式-a/b，整数直切输入）：");
			String coefficient = scanner.next();
			FractionEntity fraction = new FractionEntity();
			if (coefficient.contains("/")) { // 系数为分数
				// 设置分子
				fraction.setMolecule(Integer.parseInt(coefficient.split("/")[0]));
				// 设置分母
				fraction.setDenominator(Integer.parseInt(coefficient.split("/")[1]));
			} else { // 系数为整数
				// 设置分子
				fraction.setMolecule(Integer.parseInt(coefficient));
				// 设置分母
				fraction.setDenominator(1);
			}
			polynomialEntity.setCoefficient(fraction);
			System.out.print("请输入多项式第 " + index + 1 + " 项(从左往右)的幂：");
			polynomialEntity.setPower(scanner.nextInt());
			// 添加本次输入的单项式
			polynomial.add(polynomialEntity);
			System.out.print("是否结束输入（y / n）：");
			index++;
		} while (!scanner.next().equals("y"));
		// 前后输入的多项式幂不连续则补零
		fillZeroItem(polynomial);
	}
	
	/**
	 * 针对输入的多项式，若幂不连续（如存在0x^2或没有常数项，将其补齐）<br/>
	 * 注意：本方法默认假设多项式按最高次幂降序排序，且不存在相同幂的项
	 */
	public static void fillZeroItem(List<PolynomialEntity> polynomial) throws Exception {
		if (polynomial.isEmpty()) {
			throw new Exception("需要补零的多项式不能为空！");
		}
		Object[][] arr = new Object[2][polynomial.get(0).getPower() + 1];
		
		polynomial.forEach(PolynomialEntity -> {
			arr[0][PolynomialEntity.getPower()] = PolynomialEntity.getPower();
			arr[1][PolynomialEntity.getPower()] = PolynomialEntity.getCoefficient();
		});
		polynomial.clear();
		for (int i = arr[0].length - 1; i >= 0; i--) {
			if (arr[0][i] != null) {
				polynomial.add(new PolynomialEntity((FractionEntity) arr[1][i], (Integer) arr[0][i]));
			} else {
				polynomial.add(new PolynomialEntity(new FractionEntity(0, 1), i));
			}
		}
	}
	
}