1、掌握线性表的基本操作,插入、删除、查找,以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。
2、熟练运用掌握的线性表的操作,实现一元n次多项式的加法运算并明确规定:
输入的形式:用户输入多项式(eg:3x2 +1x1+5和1x1 +6)
输入范围:任意正整数系数、降幂排列的多项式
输出的形式:多项式相加和(eg:3x2 +2x1 +11)
程序所能达到的功能:初步计算多项式相加
2.概要设计
抽象数据类型:用数组实现的线性表类MyArrayList;
函数调用关系:主函数调用PolynomialByList类,而PolynomailByList调用MyArrayList类,实现多项式系数指数的存取;
3.详细设计
线性表类:
public class MyArrayList{
申请一个空间为0的数组;
线性表的初始长度 size = 0;
线性表下表
Add(int a){
申请一个长度比原来数组长度大1的数组
拷贝元素到新数组,在+上一个a;
将新的数组的地址赋值给原来数组
}
Insert(int index ,int a){
申请一个长度比原来数组长度大1的数组;
拷贝index之前以及之后的元素到新数组;
将index对应的a放入新数组
将新的数组的地址赋值给原来数组
}
Remove(int index int a){
和插入差不多
}
Get(int index){
Return 数组对应下表的值
}
}
链表:
Public class MyLink(){
节点类
Class Node(){
Node next;
Int data;
}
Node head;
Node tail;
Public MyLink(){
构造方法里面
申请一个空节点
Head=空节点;
Tail =空节点;
}
Add(int a){
Node newNode = New Node();
Tail.next = newNode ;
Tail = newNode ;
}
Intsert(int index ;int a){
Node newNode = new Node();
newNode.data = a;
TempNode = Head;
For(int i=0;i<index;i++){
TempNode = TempNode.next; //从头指针寻找到要插入节点的前驱
}
//找到后链接起来
newNode.next = tempNode.next.next;
tempNode.next = newNode;
}
Remove(int index int a){
和插入差不多
}
Get(int index){
TempNode = Head;
For(int i=0;i<index;i++){
TempNode = TempNode.next; //从头指针寻找到要插入节点的前驱
}
Return tempNode.next.data;
}
}
多项式计算类(用数组实现的线性表和用链表实现的线性表操作差不多):
public class PolynomialByList {
class CoeAndExp{
int coe;
int exp;
}
new 3个空的MiyArrayList,分别用来存放ABC三个多项式的系数和指数;
initData(){
获取用户输入的多项式的系数指数
New CodeAndExp();
给新new出来的系数指数对象中的coe和exp赋值
存入相应多项式
}
Calculator(){
int pa;
int pb;
先去获取a,b多项式中最高幂,然后确定循环
循环中分三个判断
1.如果a中某项的指数>b中某项指数那么把a中对应的项放到c线性表pa++
2.如果b中某项的指数>a中某项指数那么把a中对应的项放到c线性表pb++
3.如果a中某项的指数=b中某项指数那么把a中对应的项和b中对应的项系数相加后放到c线性表pa++,pb++;
}
printResult(){
for(int i=0;i<c线性表长度;i++){
syso(控制下格式);
}
}
}
4.调试分析
在程序设计中遇到错项相加的问题,然后通过system.out.println();输入循环体中的每次运算结果,发现错误的地方然后逐步求精进行调试
5.用户使用说明
1.输入多项式a;
2.输入多项式b;
3.等待结果跳出;
6.附录
//用数组实现的线性表
package cn.jinyejun.experiment_1;
public class MyArrayList<E> {
//线性表
private Object[] ArrayList;
//线性表更新大小
private int updateSize = 1;
//下标
private int index = 0;
/**
* 构造方法:初始化一个长度为0;更新大小为1的线性表
*/
public MyArrayList(){
this(0);
}
/**
* 构造方法:初始化一个长度为initSize;更新大小为1的线性表
* @param initSize 申请的初始线性表长度
*/
public MyArrayList(int initSize){
this(initSize,1);
}
/**
* 构造方法:初始化一个长度为initSize;更新大小为updateSize的线性表
* @param initSize 申请的初始线性表长度
* @param updateSize 自定义更新大小
*/
public MyArrayList(int initSize,int updateSize){
ArrayList = new Object[initSize];
this.updateSize = updateSize;
}
/**
* 增加一个元素
*/
public void add(E e){
//如果不需要扩充的话
if(index < ArrayList.length-1){
ArrayList[index++]=e;
}
//需要扩充的话
else{
Object[] ArrayList2 = new Object[ArrayList.length+updateSize];
for(int i = 0;i < ArrayList.length;i++){
ArrayList2[i] = ArrayList[i]; //copy原来线性表中的元素
}
ArrayList2[index++]=e; //增加新元素
ArrayList = ArrayList2; //将新生成的数组地址赋值给原来数组,使得原来的数组指向新的内存空间
}
}
/**
* 获得当前线性表大小
* @return 线性表长度
*/
public int getSize(){
return ArrayList.length; //本质上就是取得数组长度
}
/**
* 删除index下标的数据
* @param index
* @return 删除的数据
*/
public E remove(int index){
//判断下移除数据的下标是否越界(有效)
if(index<0||index>ArrayList.length-1){
throw new java.lang.IndexOutOfBoundsException("数组越界");
}
else{
Object[] ArrayList2 = new Object[ArrayList.length-1]; //申请新的数组,使得数组长度比原来小1;
//删除index数据
for(int i = 0;i < index;i++){
ArrayList2[i] = ArrayList[i]; //拷贝 要删除的数据 前的数据
}
for(int i = index+1;i<ArrayList2.length+1;i++){
ArrayList2[i-1] = ArrayList[i]; //拷贝 要删除的数据 后的数据
}
Object reArr = ArrayList[index]; //获取要删除的数据
ArrayList = ArrayList2; //将新生成的数组地址赋值给原来数组,使得原来的数组指向新的内存空间
return (E)reArr; //返回要删除的数据(可以用boolean,也可以返回删除值,主要是用来检测是否删除成功)
}
}
/**
* 加入元素
* @param ojb
* @param index
*/
public void insert(E e, int index){
//判断下插入数据的下标是否越界(有效)
if(index<0||index>ArrayList.length-1){
throw new java.lang.IndexOutOfBoundsException("数组越界");
}
else{
Object[] ArrayList2 = new Object[ArrayList.length+1]; //申请新的数组,使得数组长度比原来大1;
//加入index数据
for(int i = 0;i < index;i++){
ArrayList2[i] = ArrayList[i]; //拷贝 要插入的数据 前的数据
}
ArrayList2[index]=e;
for(int i = index + 1;i<ArrayList2.length;i++){
ArrayList2[i] = ArrayList[i]; //拷贝 要插入的数据 后的数据
}
ArrayList = ArrayList2; //将新生成的数组地址赋值给原来数组,使得原来的数组指向新的内存空间
}
}
/**
* 更改元素值
*/
public void setElement(E e,int index){
if(index<0||index>ArrayList.length-1){
throw new java.lang.IndexOutOfBoundsException("数组越界");
}
else{
ArrayList[index]=e; //赋值替换
}
}
/**
* 查找元素
* @param index 按下标查找
* @return (E)ArrayList[index] 下标对应的元素
*/
public E getElement(int index){
if(index<0||index>ArrayList.length-1){
throw new java.lang.IndexOutOfBoundsException("数组越界");
}
else{
return (E)ArrayList[index];
}
}
/**
* 查找元素下标
* @param e 需要查找的元素
* @return indexOfe 元素下标
*/
public int getIndex(E e){
int indexOfe = 0;
for(int i=0;i<ArrayList.length;i++){ //循环搜索
if(ArrayList[i].equals(e)){
indexOfe = i;
}else{
throw new java.lang.NullPointerException("不存在这个元素");
}
}
return indexOfe;
}
}
//用链表实现的线性表
package cn.jinyejun.experiment_1;
public class MyLink<E>{
//定义一个头节点
private Node<E> head;
//定义一个空节点
private Node<E> tempNode;
//定义一个指向队尾的节点
private Node<E> tail;
//链表的长度
private int length;
//链表节点类
class Node<E> {
Node<E> next;
Node<E> pre;
E data;
}
/**
* 创建0长度链表的构造方法
*/
public MyLink(){
this(0);
}
/**
* 创建指定长度链表的构造方法
*/
public MyLink(int size){
initLink(size);
}
/**
* 创建指定长度链表
* @param size
*/
private void initLink(int size){
//申请空节点
tempNode = new Node<E>();
//让头指针指向空节点
head = tempNode;
//让尾指针指向空节点
tail = tempNode;
int currentSize = 0;
while(currentSize<size){
add(null); //不断调用add方法给链表增加至指定长度
currentSize++;
}
}
/**
* 插入元素
* @param e:插入的元素
*/
public void add(E e){
//创建新的节点
Node<E> newNode = new Node<E>();
//把新数据添加到新创建的节点
newNode.data = e;
//让新创建的节点添加到链表后面
tail.next = newNode;
tail = newNode;
//增加链表长度
length ++;
}
/**
* 获取元素
* @param index 获取元素的下标
* @return e 获取的元素
*/
public E getElement(int index){
//如果移除下标不合法
if(index < 0 || index > length){
//抛出一个异常
throw new java.lang.ArrayIndexOutOfBoundsException("超出链表范围");
}
Node<E> temp = head;
//找到节点
for(int i = 1;i<=index;i++){
temp = temp.next;
}
//获取数据
E e = temp.data;
return e;
}
public E remove(int index){
//如果移除下标不合法
if(index < 0 || index >= length){
//抛出一个异常
throw new java.lang.ArrayIndexOutOfBoundsException("超出队列范围!");
}
//如果这个链表只有一个节点
if(length == 1){
E e = head.next.data;
head.next = null;
length--;
return e;
}
//如果删除的是第一个节点
if(index == 1){
E e = head.next.data;
head.next = head.next.next;
length--;
return e;
}
//如果删除的不是上面的节点
Node<E> temp = head;
//取得删除节点的前驱
for(int i = 1;i <index;i++){
temp = temp.next;
}
//删除节点,获取删除节点的数据
E e = temp.next.data;
temp.next = temp.next.next;
length--;
//如果删除的是尾部节点,那么把尾部前驱变成尾部节点
if(index == length){
tail = temp;
}
return e;
}
/**
* 插入节点
* @param index 插入节点的位置
* @param e 插入的数据
*/
public void insert(int index, E e){
//如果插入下标不合法
if(index < 0 || index > length){
//抛出一个异常
throw new java.lang.ArrayIndexOutOfBoundsException("超出队列范围!");
}
//如果链表长度为0,就是新增一个元素
if(length == 0){
add(e);
}
if(length != 0&&index == 1){
//创建新节点
Node<E> newNode = new Node<E>();
//新节点数据域中存放要插入的数据
newNode.data = e;
//插入节点
Node<E> temp = new Node<E>();
temp = head;
newNode.next = temp.next;
temp.next = newNode;
length ++;
}
else{
//寻找要插入的节点的前驱
Node<E> temp = new Node<E>();
temp = head;
for(int i = 1;i<index;i++){
temp = temp.next;
}
//创建新节点
Node<E> newNode = new Node<E>();
//新节点数据域中存放要插入的数据
newNode.data = e;
//插入节点
newNode.next = temp.next;
temp.next = newNode;
length++;
}
}
/**
* 获取链表长度
* @return length:链表长度
*/
public int getLength(){
return length;
}
}
用数组实现的线性表对多项式加法的操作:
package cn.jinyejun.experiment_1;
import java.util.Scanner;
/**
* 用顺序线性表实现
* 数据结构实验——多项式相加
* @author 金晔俊
* 日期:2014.3.18
*/
public class PolynomialByList {
/**
* 存放多项式系数和指数的内部类(就是多项式中的项)
*
* @author 金晔俊
*
*/
class CoeAndExp {
public int coe;
public int exp;
}
//定义三个线性表用来存储a,b,c三个多项式的系数和指数,其中a,b为用户输入的多项式,c为计算出来的多项式
private MyArrayList<CoeAndExp> pna = new MyArrayList<CoeAndExp>();
private MyArrayList<CoeAndExp> pnb = new MyArrayList<CoeAndExp>();
private MyArrayList<CoeAndExp> pnc = new MyArrayList<CoeAndExp>();
public PolynomialByList() {
//初始化用户输入的多项式
initData();
//计算多项式
calculator();
//输出计算结果
printResult();
}
/**
* 让用户输入两个多项式,初始化数据
*/
private void initData() {
// 获取A多项式的系数指数
cinPn('a');
// 获取B多项式的系数指数
cinPn('b');
}
/**
* 处理用户输入的字符串,并且提示用户输入相应多项式
* @param ch
*/
private void cinPn(char ch) {
// 用来给系数和指数轮流复制的标志
boolean flag = true;
int indexOfList = 0;
// 提醒用户输入多项式
System.out.println("请输入多项式" + ch + "(输入格式:4x5 + 1x4 + 2x3 + 5x2 + 1x1 + 1)");
// 获取用户输入的多项式
Scanner cin = new Scanner(System.in);
String multi = cin.nextLine();
// 将获取来的字符串按字符保存在数组中
char[] arry = multi.toCharArray();
// 将用户输入的多项式的系数指数存放到pn线性表中
for (int i = 0; i < arry.length; i++) {
// 判断是否是字母x或者加号和空格,否则按顺序给pn线性表中相应的成员赋值
// System.out.println(arry.length+"循环"+i);
if (arry[i] != 'x' && arry[i] != ' ' && arry[i] != '+') {
if (ch == 'a') {
// System.out.println("__");
if (flag) {
// System.out.println("??");
CoeAndExp newCoeAndExp = new CoeAndExp(); //申请新的系数指数存放对象
newCoeAndExp.coe = Integer.parseInt("" + arry[i]); //给系数赋值
pna.add(newCoeAndExp); //将新申请的对象存放到线性表a中
flag = false;
} else {
pna.getElement(indexOfList).exp = Integer.parseInt(""
+ arry[i]); //给指数赋值
indexOfList++; //线性表长度加1(表示此系数指数对象赋值处理完毕)
flag = true;
}
} else {
if (flag) {
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = Integer.parseInt("" + arry[i]);
pnb.add(newCoeAndExp);
flag = false;
} else {
pnb.getElement(indexOfList).exp = Integer.parseInt(""
+ arry[i]);
indexOfList++;
flag = true;
}
}
}
}
}
/**
* 计算用户输入的两个多项式之和
*/
private void calculator() {
//定义一个游标用来指向a多项式
int a = 0;
//定义一个游标用来指向b多项式
int b = 0;
//获取a,b中最高次幂
int maxExp = Math.max(pna.getElement(0).exp, pnb.getElement(0).exp);
//用循环去给a,b进行操作
for (int x = 0; x < maxExp + 1; x++) {
//如果a中某项指数小于b,那么把b添加到c多项式线性表中
if (pna.getElement(a).exp < pnb.getElement(b).exp) {
//System.out.println("x="+x+"a="+a+"b="+b); //出现错位相加的错误的时候可以使用这种方法调试
//创建c中新的项
CoeAndExp newCoeAndExp = new CoeAndExp();
//给这项的系数,指数赋值
newCoeAndExp.coe = pnb.getElement(b).coe;
newCoeAndExp.exp = pnb.getElement(b).exp;
//System.out.println(newCoeAndExp.coe+""+newCoeAndExp.exp);
//将这项添加到c多项式中
pnc.add(newCoeAndExp);
//用来检查是不是b多项式要到末尾了
if (b < pnb.getSize() - 1) {
b++; //添加完成后b游标往后移动(准备对下一个项进行操作)
} else {
//System.out.println("b到达末尾");
break;
}
//如果a中某项指数大于b,那么把a添加到c多项式线性表中
} else if (pna.getElement(a).exp > pnb.getElement(b).exp) {
//System.out.println("x="+x+"a="+a+"b="+b);
CoeAndExp newCoeAndExp = new CoeAndExp(); //创建C中新的项
//赋值
newCoeAndExp.coe = pna.getElement(a).coe;
newCoeAndExp.exp = pna.getElement(a).exp;
//System.out.println(newCoeAndExp.coe+""+newCoeAndExp.exp);
//将新创建的项添加到c线性表中
pnc.add(newCoeAndExp);
if (a < pna.getSize() - 1) {
a++; //添加完成后a游标往后移动(准备对下一个项进行操作)
} else {
//System.out.println("a到达尾部");
break;
}
} else {
//如果a中某项指数等于b,那么把a,b中该项相加后,添加到c多项式线性表中
//System.out.println("x="+x+"a="+a+"b="+b);
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = pna.getElement(a).coe + pnb.getElement(b).coe;
newCoeAndExp.exp = pna.getElement(a).exp;
//System.out.println(newCoeAndExp.coe+""+newCoeAndExp.exp);
pnc.add(newCoeAndExp);
if (a < pna.getSize() - 1 && b < pnb.getSize() - 1) {
a++; //a,b游标都得往后移动
b++;
} else {
//System.out.println("ab到达尾部");
break;
}
}
}
//************加上剩余的多项式*************//
//如果b没到尾部,那么加上b中的剩余多项式
if(b < pnb.getSize()-1){
for(int i = b;i<pnb.getSize();i++){
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = pnb.getElement(i).coe;
newCoeAndExp.exp = pnb.getElement(i).exp;
pnc.add(newCoeAndExp);
}
}
//如果a没到尾部,那么加上a中的剩余多项式
if(a < pna.getSize()-1){
for(int i = a;i<pna.getSize();i++){
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = pnb.getElement(i).coe;
newCoeAndExp.exp = pnb.getElement(i).exp;
pnc.add(newCoeAndExp);
}
}
}
/**
* 打印计算结果(就是遍历线性表c,用规定格式输出)
*/
private void printResult() {
System.out.println("a,b多项式相加后的结果为:");
for (int x = 0; x < pnc.getSize(); x++) {
// System.out.println("+:+<");
if (pnc.getElement(x).exp != 0) {
System.out.print(" "+pnc.getElement(x).coe + "x"
+ pnc.getElement(x).exp + " " + "+");
} else {
System.out.print(" "+pnc.getElement(x).coe);
}
}
}
/**
* 主函数,程序执行的入口
* @param args
*/
public static void main(String[] args) {
new PolynomialByList();
}
}
用链表实现的线性表对多项式的加法操作:
package cn.jinyejun.experiment_1;
import java.util.Scanner;
/**
* 用链表实现
* 数据结构实验——多项式相加
* @author 金晔俊 日期:2014.3.18
*/
public class PolynomialByLink {
//定义三个链表用来存储a,b,c三个多项式的系数和指数,其中a,b为用户输入的多项式,c为计算出来的多项式
private MyLink<CoeAndExp> pna = new MyLink<CoeAndExp>();
private MyLink<CoeAndExp> pnb = new MyLink<CoeAndExp>();
private MyLink<CoeAndExp> pnc = new MyLink<CoeAndExp>();
public PolynomialByLink() {
//初始化用户输入的多项式
initData();
//计算多项式
calculator();
//输出计算结果
printResult();
}
/**
* 让用户输入两个多项式,初始化数据
*/
private void initData() {
// 获取A多项式的系数指数
cinPn('a');
// 获取B多项式的系数指数
cinPn('b');
}
/**
* 处理用户输入的字符串,并且提示用户输入相应多项式
* @param ch
*/
private void cinPn(char ch) {
// 用来给系数和指数轮流复制的标志
boolean flag = true;
int indexOfList = 1;
// 提醒用户输入多项式
System.out.println("请输入多项式" + ch + "(输入格式:4x5 + 1x4 + 2x3 + 5x2 + 1x1 + 1)");
// 获取用户输入的多项式
Scanner cin = new Scanner(System.in);
String multi = cin.nextLine();
// 将获取来的字符串按字符保存在数组中
char[] arry = multi.toCharArray();
// 将用户输入的多项式的系数指数存放到pn链表中
for (int i = 0; i < arry.length; i++) {
// 判断是否是字母x或者加号和空格,否则按顺序给pn链表中相应的成员赋值
// System.out.println(arry.length+"循环"+i);
if (arry[i] != 'x' && arry[i] != ' ' && arry[i] != '+') {
if (ch == 'a') {
// System.out.println("__");
if (flag) {
// System.out.println("??");
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = Integer.parseInt("" + arry[i]);
pna.add(newCoeAndExp);
flag = false;
} else {
pna.getElement(indexOfList).exp = Integer.parseInt(""
+ arry[i]);
indexOfList++;
flag = true;
}
} else {
if (flag) {
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = Integer.parseInt("" + arry[i]);
pnb.add(newCoeAndExp);
flag = false;
} else {
pnb.getElement(indexOfList).exp = Integer.parseInt(""
+ arry[i]);
indexOfList++;
flag = true;
}
}
}
}
}
/**
* 计算用户输入的两个多项式之和
*/
private void calculator() {
//定义一个指针用来指向a多项式
int a = 1;
//定义一个指针用来指向b多项式
int b = 1;
//获取a,b中最高次幂
int maxExp = Math.max(pna.getElement(1).exp, pnb.getElement(1).exp);
//用循环去给a,b进行操作
for (int x = 1; x <= maxExp + 1; x++) {
//如果a中某项指数小于b,那么把b添加到c多项式链表中
if (pna.getElement(a).exp < pnb.getElement(b).exp) {
//System.out.println("x="+x+"a="+a+"b="+b);
//创建c中新的项
CoeAndExp newCoeAndExp = new CoeAndExp();
//给这项的系数,指数赋值
newCoeAndExp.coe = pnb.getElement(b).coe;
newCoeAndExp.exp = pnb.getElement(b).exp;
//System.out.println(newCoeAndExp.coe+""+newCoeAndExp.exp);
//将这项添加到c多项式中
pnc.add(newCoeAndExp);
//用来检查是不是b多项式要到末尾了
if (b < pnb.getLength()) {
b++;
} else {
//System.out.println("b到达末尾");
break;
}
//如果a中某项指数大于b,那么把a添加到c多项式链表中
} else if (pna.getElement(a).exp > pnb.getElement(b).exp) {
//System.out.println("x="+x+"a="+a+"b="+b);
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = pna.getElement(a).coe;
newCoeAndExp.exp = pna.getElement(a).exp;
//System.out.println(newCoeAndExp.coe+""+newCoeAndExp.exp);
pnc.add(newCoeAndExp);
if (a < pna.getLength()) {
a++;
} else {
//System.out.println("a到达顶峰");
break;
}
} else {
//如果a中某项指数等于b,那么把a,b中该项相加后,添加到c多项式链表中
//System.out.println("x="+x+"a="+a+"b="+b);
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = pna.getElement(a).coe + pnb.getElement(b).coe;
newCoeAndExp.exp = pna.getElement(a).exp;
//System.out.println(newCoeAndExp.coe+""+newCoeAndExp.exp);
pnc.add(newCoeAndExp);
if (a < pna.getLength()&& b < pnb.getLength()) {
a++;
b++;
} else {
//System.out.println("ab到达顶峰");
break;
}
}
}
//加上剩余的多项式
//如果b没到底部,那么加上b中的剩余多项式
if(b < pnb.getLength()){
for(int i = b;i<=pnb.getLength();i++){
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = pnb.getElement(i).coe;
newCoeAndExp.exp = pnb.getElement(i).exp;
pnc.add(newCoeAndExp);
}
}
//如果a没到底部,那么加上a中的剩余多项式
if(a < pna.getLength()){
for(int i = a;i<=pna.getLength();i++){
CoeAndExp newCoeAndExp = new CoeAndExp();
newCoeAndExp.coe = pnb.getElement(i).coe;
newCoeAndExp.exp = pnb.getElement(i).exp;
pnc.add(newCoeAndExp);
}
}
}
/**
* 打印计算结果
*/
private void printResult() {
System.out.println("a,b多项式相加后的结果为:");
for (int x = 1; x <= pnc.getLength(); x++) {
// System.out.println("+:+<");
if (pnc.getElement(x).exp != 0) {
System.out.print(" "+pnc.getElement(x).coe + "x"
+ pnc.getElement(x).exp + " " + "+");
} else {
System.out.print(" "+pnc.getElement(x).coe);
}
}
}
/**
* 主函数,程序执行的入口
* @param args
*/
public static void main(String[] args) {
new PolynomialByLink();
}
/**
* 存放多项式系数和指数的内部类
*
* @author 金晔俊
*
*/
class CoeAndExp {
public int coe;
public int exp;
}
}