java 数据结构：数组多项式与链表多项式

实验目的：
以一个简单的实例， 复习 java 程序设计语言、 接口以及重载
实验内容：
一个一元四次多项式按升幂的形式可写成： p(x) = 𝑎0 + 𝑎1𝑥 + 𝑎2𝑥² + 𝑎3𝑥³ + 𝑎4𝑥4，的
形式，因此一组数（𝑎0， 𝑎1， 𝑎2， 𝑎3， 𝑎4） 可以唯一的表示一个多项式。

1. 定义多项式接口 interface Polynomial{}，包括两个公有方法，分别是：设置多项式所
   有系数 set（）（从工作台读取键盘输入 5 个系数）、读取多项式第 i 个系数 get（int
   i）。
2. 设计类 ArrayPolynomial 实现接口， 除了实现接口的两个方法外， 该类还应包括一
   个数组用于存储多项式系数， 一个构造方法初始化数组，为数组分配 5 个存储空
   间。 以及一个修改多项式第 i 个系数的方法 setElement（int i）
3. 为了实现链式存储， 设计结点类， 包括两个成员变量： 一个实数系数和一个结点类
   用于指向下一个结点。
4. 设计类 LinkPolynomial 实现接口， 除了实现接口的两个方法外， 该类还应包括一个
   Node 类型的头结点 head， 一个构造方法初始化头结点（new Node）
5. 设计方法 addPolynomial， 参数为一个 ArrayPolynomial 对象和一个 LinkPolynomial 对
   象， 返回两个多项式相加的结果， 返回类型为 ArrayPolynomial
6. 设计两个方法名相同但参数类型不同的方法 computePolynomial， 该方法有两个参
   数： x 的值和多项式（ArrayPolynomial 或者 LinkPolynomial）
7. Main 函数中分别建立 ArrayPolynomial 对象和 LinkPolynomial 对象， 将两个对象所
   代表的多项式相加后计算多项式的值（x 的值可以在 main 函数中设置或者从键盘
   输入）。

package com.linjingshu.exer1;
import java.util.*;

/**
 * @author ljs
 * @create 2020-09-09-13:04
 */
public class lab1 {
    //定义接口
    public interface Polynomial
    {
        void set() throws Exception;
        float get(int i);
    }

    //定义ArrayPolynomial类
    public static class ArrayPolynomial implements Polynomial
    {
        private float[] polynomial;

        //构造函数
        public ArrayPolynomial()
        {
            polynomial = new float[5];
        }
        //从键盘读入5个浮点数，赋值给多项式数组
        @Override
        public void set()
        {
            Scanner in = new Scanner(System.in);
            for (int i = 0; i < 5; i++) {
                polynomial[i] = in.nextFloat();
            }
        }
        //返回多项式的第i个系数值
        @Override
        public float get(int i)
        {
            return polynomial[i-1];
        }

    }
    //定义链式存储的结点,包含两个成员变量：
    //一个表示数据的float变量和一个表示下一个结点的Node变量
    public static class Node
    {
        float dataValue;
        Node next;
    }
    //定义链类，
    public static class LinkPolynomial implements Polynomial
    {	//定义成员变量head，表示链表的第一个结点head
        private Node head;

        //定义构造函数，为成员变量head分配一个Node空间
        public LinkPolynomial()
        {
            head = new Node();
        }
        //从键盘读入5个浮点数，赋值给多项式数组
        //参考pdf文件中第三页遍历函数，依次访问每个元素并赋值

/**
 * 假设head这个对象的指向内存的指针是400
 * 再声明一个中转阶段other，此时other和head都是同一个指针400，指向实际的一个内存对象
 * 第一次for遍历时候，先创建一个临时对象temp，指向指针为401的一个内存对象
 * 将401这个指针关联到指针400的next上，这时候head=other，即 400.next=401，此时401.next为空
 * 循环中最后一步将other的指针从400切换为401，即此时head还是400那个对象，head的next为指针401的那个对象
 * 第二次for循环时候，创建一个指针为402的对象temp
 * 将401的next指向402，即此时root的状态为400.next=401，而此时401.next=402，形成的链表即为400->401->402
 * 循环的最后一步又将other指针切换为402
 * 第三次for循环，创建一个指针为403的对象temp
 * 将402的next指向403，即即此时head的状态为400.next=401，401.next=402，402.next=403，形成的链表即为400->401->402->403
 * 经过函数若干次循环后，head最终就会是将一个{400, 401, 402, 403, 404, 405}这样的数组转换为400->401>402->403->404->405的链表结构
 * */
        public void set() {
            float[] values = new float[5];

            Scanner in = new Scanner(System.in);
            for (int i = 0;i<4;i++){
                values[i] = in.nextFloat();
            }
            //数组转换成链表
            head.dataValue = values[0];
            Node other = head;
            for (int i =1;i<values.length;i++){
                Node temp = new Node();
                temp.dataValue = values[i];
                other.next = temp;
                other = temp;
            }
        }
       //还有更好的方法↓，之前是自己脑抽，画蛇添足
        public void set(){
            Scanner in = new Scanner(System.in);
            Node temp = head;
            for (int i = 0;i<4;i++){
                temp.dataValue = in.nextFloat();
                temp.next = new Node();
                temp = temp.next;
            }
            temp.dataValue = in.nextFloat();
        }

        //返回多项式地第i个系数
        //参考pdf文件中第三页地遍历函数，遍历到第i个结点，返回其数据值
        @Override
        public float get(int i)
        {
            Node temp = head;
            for (int j = 0;j<i;j++){
                if (temp.next == null){
                    break;
                }
                temp = temp.next;
            }
            return temp.dataValue;
        }

    }
    //定义方法，讲一个链表多项式和一个数组多项式相加，保存在一个数组多项式中，并返回该多项式
    public ArrayPolynomial addPolynomial(ArrayPolynomial p1,LinkPolynomial p2)
    {
        ArrayPolynomial ap2 = new ArrayPolynomial();
        for (int i = 0;i<5;i++){
            ap2.polynomial[i] = p1.get(i+1)+p2.get(i);
        }
        return ap2;
    }
    //给出ArrayPolynomial p1和x，计算多项式的值并返回
    public float computePolynomial(ArrayPolynomial p1,float x)
    {
        float sum1 = 0;
        for (int i = 0;i<5;i++){
            sum1 += p1.get(i+1)*Math.pow(x,i);
        }
        return sum1;
    }
    //给出LinkPolynomial p1 和x，计算多项式的值并返回
    public float computePolynomial(LinkPolynomial p1,float x)
    {
        float sum2 = 0;
        for (int i = 0;i<5;i++){
            sum2 += p1.get(i)*Math.pow(x,i);
        }
        return sum2;
    }
    public static void main(String[] args) {
        lab1 lab1 = new lab1();
        //定义两个对象，分别是ArrayPolynomial类和 LinkPolynomial类
        ArrayPolynomial arrayPolynomial = new ArrayPolynomial();
        LinkPolynomial linkPolynomial = new LinkPolynomial();
        //分别使用set方法对ArrayPolynomial对象和LinkPolynomial对象赋值
        System.out.println("请输入数组多项式的5个系数：");
        arrayPolynomial.set();
        System.out.println("请输入链表多项式的5个系数");
        linkPolynomial.set();
        //定义一个ArrayPolynomial 对象，用来保存两个多项式相加的结果
        ArrayPolynomial arrayPolynomial1;
        arrayPolynomial1 = lab1.addPolynomial(arrayPolynomial,linkPolynomial);
        //调用computePolynomial方法分别计算三个多项式地值并在屏幕上输出
        float sum1 = lab1.computePolynomial(arrayPolynomial,2);
        float sum2 = lab1.computePolynomial(linkPolynomial,3);
        float sum3 = lab1.computePolynomial(arrayPolynomial1,4);
        System.out.println("sum1 = "+sum1+" sum2 = "+sum2+" sum3 = "+sum3);
    }
}