1．需求分析
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;
}
}
很长！赞一个
相关推荐
数组、链表、堆栈和队列、线性表和顺序表 数组和链表.pdf
顺序表和数组（易混淆），线性表，链表的区别与联系 数组和链表.pdf
c语言数组指定位置插入和删除-玩转C语言链表，单链表双向链表的建立遍历插入删除... 数组和链表.pdf
用java实现了各种线性表（表，队列，栈等），包括顺序数组实现和链表实现
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
Java编写的线性表和链表，用于理解数据结构中的线性表和动态链表，使用Java原生sdk实现，可以运行。
链表是一种常用的组织有序数据的数据结构，它通过指针将一系列数据节点连接成一条数 据链，是线性表的一种重要实现方式。相对于数组，链表具有更好的动态性，建立链表时无需预先知道数据总量，可以随机分配空间，...
数据结构实验内容：线性表（顺序表实现）、线性表（单链表实现）、栈、字符串、多维数组（三元组表存矩阵）、二叉树（二叉链表和顺序表存储）、邻接表存图以及图的遍历、排序 实验报告部分只要求了线性表、栈、多维...
（1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点...
学习实现一元n次多项式的加法是符号多项式的操作，是表处理的典型用例，需要注意的是：顺序存储结构指的是用数组方法，使用数组方法实现时，在插入和删除的方面，数组不如链表灵活，方法复杂，删除其中一个需要将其...
能够正常运行，是基于C++编写的代码，包括，数组线性表，链表线性表、双向链表、顺序栈、链栈、链队列，顺序队列，循环队列、KMP算法、二叉树前、中、后、层次遍历（包含递归和非递归）、二叉树前、中线索遍历算法、...
基于Python的list实现的链表结构。由于不必按顺序存储，链表在插入的时候可以达到O⑴的...使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。
顺序表，使用数组实现，一组地址连续的存储单元，数组大小有两种方式指定，一是静态分配，二是动态扩展。 注：线性表从1开始，而数组从0开始。 优点：随机访问特性，查找O(1)时间，存储密度高；逻辑上相邻的元素，...
利用C++实现以下经典数据结构与算法：线性表（顺序表、链表、静态链表、三元组）、栈（双栈、共享栈）、队列（任务调度、循环队列、双向队列、链队列）、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法...
线性表的基本操作，如建立、查找、插入和删除等 包括链表及顺序表
链表是一种常用的组织有序数据的数据结构，它通过指针将一系列数据节点连接成一条数据链，是线性表的一种重要实现方式。相对于数组，链表具有更好的动态性，建立链表时无需预先知道数据总量，可以随机分配空间，可以...
本程序主要目的在于帮助同学熟练掌握线性表的基本 操作在顺序存储结构上的实现，顺序表的优点是可以实现随机存取，用数组对其进行定义， 主要操作时针对数组下标的运算。本实验相对比较简单，通过本实验，对顺序表...
包含数据结构中线性表、链表、队列、栈、串等几种结构的常见操作，以及顺序和链式存储过程
能够正常运行，是基于C++编写的代码，包括，数组线性表，链表线性表、双向链表、顺序栈、链栈、链队列，顺序队列，循环队列、KMP算法、二叉树前、中、后、层次遍历（包含递归和非递归）、二叉树前、中线索遍历算法、...
对于线性链表，也可用一维数组来进行描述。这种描述方法便于在没有... 这种存储结构，仍需要预先分配一个较大的空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改指针，故仍具有链式存储结构的主要优点。