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中，数组是最基本的线性数据结构，可以存储同一类型的元素。通过...
对于顺序线性表，可以使用数组并配合动态内存分配来处理大小变化的情况。 总的来说，理解和掌握线性表的这两种实现方式对于学习和实践数据结构至关重要，它们提供了处理和组织数据的基本工具，为更复杂的数据结构和...