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;
}
}
很长！赞一个
相关推荐
链表可以使用数组来实现，也可以使用指针来实现，而顺序表只能使用数组来实现。 数据结构的基础知识包括逻辑结构、物理结构、线性表、顺序表、数组、链表等概念。只有牢固掌握这些基础知识，才能更好地理解和应用...
数组、链表、堆栈和队列、线性表和顺序表 数组、链表、堆栈和队列是最基本的数据结构，任何程序都会涉及到其中的一种或多种。数据结构是指数据之间的相互关系，即组织形式，有逻辑结构和物理结构之分。逻辑结构有...
在Java中，我们通常使用数组或链表来实现线性表。本话题聚焦于使用动态数组来实现线性表，这是一种常见的数据结构实现方式，因为它既保留了数组的高效访问特性，又能灵活地调整大小以适应数据的变化。 动态数组，也...
线性表有两种主要的实现方式：顺序表（基于数组）和链式表（基于链表）。 顺序表，即用数组实现的线性表，其特点是内存中存储的数据是连续的。这使得随机访问变得非常高效，通过索引可以直接访问到所需元素。然而，...
数组是一种线性表的顺序存储结构，其主要特性包括支持随机访问和占用连续的存储空间。Python本身虽然没有直接的数组结构，但列表(list)可以作为其替代品，通过索引可以快速访问任意位置的元素。然而，当数据量较大时...
1. 数组和链表都可以叫做线性表。数组又叫做顺序表，主要区别在于，顺序表是在内存中开辟一段连续的空间来存储数据，而链表是靠指针来连接多块不连续的空间，在逻辑上形成一块连续的空间来存储数据。 2. 数组静态...
遍历输出线性表是指顺序扫描输出线性表中的每个元素。这个操作可以用来输出线性表中的所有元素。例如，traverseList函数可以用来遍历输出线性表： void traverseList(struct List *L) 7. 查找线性表中的元素 查找...
在实际应用中，数组可以实现顺序表、链表和树等多种逻辑结构。顺序表、链表和数组之间的关系是非常复杂的，每种结构都有其特点和优缺点，需要根据实际情况选择合适的结构。 数据结构顺序表、链表和数组是逻辑结构...
顺序表就是使用数组实现的线性表，元素之间存在一对一的关系，可以通过下标进行访问。线性表的操作包括插入、删除、查找等。 3. **数组实现线性表的优势** - **随机访问**：由于数组的连续存储特性，我们可以直接...
在这个压缩包中，我们关注的是“线性表”的实现，特别是使用链表来构建这一基础数据结构。 线性表是一种抽象的数据类型，它由n（n≥0）个相同类型的元素按特定顺序排列组成。这些元素可以是数字、字符串、对象等。...
线性表可以用数组或链表来实现，本文中我们使用顺序存储的方式，即使用数组来存储元素。 线性表的实现需要定义一个类，包括构造函数、析构函数、输入函数、输出函数和归并函数等。构造函数用于分配内存空间，析构...
在计算机科学中，链表是实现线性表的一种常见方式，尤其在C语言中，由于没有内置的动态数组，链表成为了处理动态数据集合的重要手段。本文将深入探讨如何用C语言实现线性表的各种操作，包括创建、插入、删除、查找等...
在C++或Python等编程语言中，可以使用数组或链表来实现队列。 二叉树是每个节点最多有两个子节点的树形结构，通常分为二叉搜索树、完全二叉树、平衡二叉树（如AVL树和红黑树）等类型。二叉树的常用操作有插入、删除...
数组实现的线性表可以使用顺序映像来存储数据元素，而链表实现的线性表可以使用链式映像来存储数据元素。 线性表的应用非常广泛，例如在数据库中存储数据，在编程语言中实现数组和链表等。在实际应用中，线性表的...
顺序栈是栈的一种实现方式，可以使用数组或链表实现。在顺序栈中，栈顶元素是最先被插入的元素，也是最先被删除的元素。链栈则使用链表作为底层数据结构，插入和删除操作在链表头部进行，即每次操作都在链表头节点...
顺序线性表是一种基本的数据结构，它在计算机科学中扮演着重要的角色，特别是在数组和链表等基础数据结构的学习中。顺序线性表是通过数组实现的，元素按线性顺序存储，每个元素都有一个固定的位置，可以通过索引来...
在这个"数组实现线性表-VS2015"项目中，我们将深入探讨如何使用C++语言和Visual Studio 2015开发环境来创建和操作线性表。 1. **数组的概念**：数组是C++中预定义的数据类型，它允许我们在内存中存储一组具有相同...
在Java中，我们通常通过两种方式来实现线性表：数组和链表。下面将详细讨论这两种实现方式及其操作。 一、数组实现线性表 1. **数组定义**：在Java中，数组是最基本的线性数据结构，可以存储同一类型的元素。通过...