189 8069 5689
package Test;
创新互联公司专注于金坛企业网站建设,响应式网站开发,成都做商城网站。金坛网站建设公司,为金坛等地区提供建站服务。全流程按需定制，专业设计，全程项目跟踪，创新互联公司专业和态度为您提供的服务
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringBufferInputStream;
import java.io.StringReader;
import java.util.Scanner;
class Test {
private static Node firstList, secondList, resultList;
private static void input(Node head) throws Exception {
int a;
int b;
int i;
Node p = head;
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
// 读取一行信息
String input = reader.readLine();
// 以空格为分隔符，转换成数组
String[] numbers = input.split(" ");
for(i=0;inumbers.length;){
a = Integer.parseInt(numbers[i]);
b = Integer.parseInt(numbers[i+1]);
p.next = new Node(a, b);
p = p.next;
i+=2;
}
}
public static void main(String[] args) throws Exception {
firstList = new Node();
secondList = new Node();
resultList = new Node();
Node p=resultList;
System.out.println("输入第一个多项式");
input(firstList);
System.out.println("输入第二个不等式");
input(secondList);
while(firstList.next!=nullsecondList.next!=null){
if(firstList.next.zssecondList.next.zs){
p.next=new Node(firstList.next.xs,firstList.next.zs);
p=p.next;
firstList=firstList.next;
}else if(firstList.next.zssecondList.next.zs){
p.next=new Node(secondList.next.xs,secondList.next.zs);
p=p.next;
secondList=secondList.next;
}else{
p.next=new Node(firstList.next.xs+secondList.next.xs,firstList.next.zs);
p=p.next;
firstList=firstList.next;
secondList=secondList.next;
}
}
if(firstList!=null){
p.next=firstList.next;
}
if(secondList!=null){
p.next=secondList.next;
}
p=resultList;
while(p.next!=null){
System.out.print(p.next.xs+"x^"+p.next.zs+"+");
p=p.next;
}
System.out.println();
}
}
public class Node {
public int xs;//系数
public int zs;//指数
public Node next=null;//指向下一个
public Node(int a,int b) {
xs=a;
zs=b;
}
public Node(){
}
}
答案
输入第一个多项式
5 4 3 2 1 1
输入第二个不等式
4 4 3 2 1 1
9x^4+6x^2+2x^1
＃包括“stdio.h中”
typedef结构节点
{C，E / /节点的数据域，C为系数的多项式e多项式指数
结构节点下/ /节点的指针字段
} PN / /自定义的节点结构类型PN
PN * createPoly（）/ /这个函数用于创建一个链表，返回值是一个节点的指针
{N，E，C;
PN *头，* P / /定义头结点指针头节点的指针p
printf（“请输入项目编号项目：“）;
scanf的（”％d“，＆N）; / / n的值，无论是项目的数量
头= P = PN / / * malloc的（大小（PN））;/ /头，p指向头节点（头节点不必存储的数据）
P- = NULL; / /这里，创建一个空列表
（ - ）/ /循环n次
{
P- =新PN ;/ / * malloc的（如sizeof（PN））;/ /动态分配新的节点，然后在链末端（尾插）
P = P-下;
/ / printf的（“CE”）; / /到新的节点，添加数据
scanf的（“ ％d月％d“，＆P- C：P- E）;
}
P- = NULL; / /指针域页脚设置为空
返回头; / /返回头节点地址
}
无效printPoly（PN *头）/ /这个函数是用来
{PN * P =头下输入链接的列表信息; / /用来遍历链表节点指针P，P点的表头
（P）/ /当p = NULL的表底，在周期结束
{printf（“请（％D，％D）”，P- C，P- E）/ /显示当前节点的数据
P = P-; / / P点移动到下一个节点
}
printf的（“\ n”）; / /输出一个回车
}
的无效freePoly（PN *头）/ /函数是用来摧毁的链表
{PN * P / /释放节点（动态内存块）
同时（头）/ /头= NULL（已经到了结束的表），在循环结束
{P =头; / /让p指向头节点称为
头=头下; / /指向头移动到下一个节点/删除（P）/ / P所指节点释放（动态内存块）
}
}的
PN * polyAdd的（PN公顷，PN * HB）/ /这个函数两个多项式的总和
{C，E; / / C是多项式的系数，e是多项式指数
PN * PA = HA-下一个* PB = HB-下，/ /？PA，PB用于遍历两个链表传递的参数（参数两个链表的头结点指针），让我们称呼他们为链表AB
* HC，* PC / / HC新列表头的总和的两个列表中的相应节点的节点，PC，用于遍历新的列表，链接列表的称之为C
HC = PC =新PN;
（PA |以pb计）/ /当两个链表的遍历完成循环停止
{
（PA （PB == NULL | | PA- E E））/ /取指数项链成一个链表或链接列表b遍历完成后，执行内容
，如果{C = PA- C;
E = PA- E;
PA = PA-下;
}
其他（PB （PA == NULL | | PA- E PB- E））/ /走索引就是少了一个项链成一个链表，链表的遍历完成实施的内容，如果
{C = PB- C;
E = PB- E;
PB = PB-;
}
/ /指数等于执行
{C = PA- C + PB- C;
E = PA- E;
PA = PA-下;
PB = PB-下;
}
（C）/ /添加一个链接到一个新的列表清单 BR / {
PC-下一个新的PN;
PC = PC-
PC - C = C;
PC- E = E; BR /}
}
PC-下一个= NULL;
回报HC / /返回一个新的列表头节点的指针
}的
PN * mulxmul的（PN公顷PN HB）/ /这个函数是每个项目表关闭一次onexmul功能，并最终实现多项式乘法的a和b
{PN * T * HC，* PA = HA-“下;
PN * onexmul（PN * PA，PN * HB）/ /函数的声明，因为下一个步骤是使用
PN * polyAdd的（ PN *公顷，PN * HB）/ /函数声明，因为下一个步骤是使用
T =新的PN，T - = NULL; / /存储最终的结果链表，t为头，该表姑且称之为T台上
（PA）/ /遍历一个链表
{HC = onexmul（PA，HB）; / / PA所指的项目表中的b表所有的项目都乘以（即多项式多项式B乘）
T = polyAdd（T，HC）; / /将分别相乘的结果中添加
freePoly（HC）; / /将调用onexmul功能生产破坏中间的链表，链表的项目已经在t链表
PA = PA-下;
}
回报吨; / / T-表头结点指针返回
}
PN * onexmul的（* PA，PN PN * HB）/ /这个函数是用来PA所指的项目表中的b表项相乘（即多项式一个多项式B相乘）
{PN * HC，PC，PB = HB-; / / HC是新的列表头节点，PC遍历新的列表 BR / HC = PC = PN / / HC，PC指向头节点
一段时间（以pb计）/ /遍历b链接列表
{PC-下一步= PN / /创建一个新的链表节点
PC = PC - 下;
PC- C = PA- C * PB- C; / /到新的节点分配的系数，系数等于乘以
PC- E = PA - E + PB- E / /指数指数总和等于
PB = PB-下;
}
PC - 下一步= NULL;
返回HC / /新的列表头节点的指针返回
}
诠释的main（）
{ PN *下*，HB，HC;
freopen（“; poly.in”，“R”状态，stdin）; / /只读模式poly.in
freopen（“poly.txt “，”W“中，stdout）; / /只写模式打开poly.txt
公顷= createPoly（）/ /创建一个新的链接列表，哈头节点的指针（多项式）
printPoly医管局总（公顷）; / /输出节点的指针链表信息
HB = createPoly（）/ /创建一个新的链接列表，HB头节点指针（多项式）
printPoly（HB）; / /输出HB头节点的指针链表信息
HC = polyAdd（HA，HB）/ /多项式一个多项式B和结果，HC是头节点的指针链表
printPoly（HC） /添加/输出链表信息
freePoly（HC）; / /销毁链表的
HC = mulxmul（HA，HB）/ /多项式一个多项式B相乘的结果，HC头节点的指针
printPoly（HC）/ /输出链表的信息后乘以链表
freePoly（公顷）; / /销毁链表
freePoly（HB）; / /销毁链表
freePoly（HC）; / /销毁的链表
返回0;
}
OK，花了大量的时间来帮你写下来笔记，完整的，完全一样的原理和数学模型，它应该是能读“，”流程图“，相信，理解程序，它是难以划清，尝试下。
package ba;
//线性表抽象数据类型的java接口定义
interface List
{
public boolean isEmpty(); //接口方法1：判断线性表是否为空
public void insert(int i ,int element) throws Exception; //接口方法2：在线性表的指定位置插入数据元素
public int remove(int i) throws Exception; //接口方法3：删除线性表中指定位置的数据元素
public int getData(int i) throws Exception; //接口方法4：获取线性表中指定位置的数据元素
public int length(); //接口方法5：获取线性表的长度（数据元素的个数）
}
//顺序表类SeqList，实现线性表接口
class SeqList implements List
{
//在实现接口的类中定义成员变量
private int[] listArray; //定义数组：listArray，用于保存线性表中的数据元素
final int defaultSize=10; //定义常量：defaultSize，用于指定线性表的默认长度
private int size; //定义变量：size，用于描述线性表中的数据元素的个数（线性表的长度）
private int maxSize; //定义变量：maxSize，用于描述线性表中最大数据元素的个数（线性表的最大长度）
//在实现接口的类中定义成员方法
//构造方法
//定义函数：initiate()
public void initiate(int sz)
{
maxSize=sz;
size=0;
listArray=new int[sz]; //创建一个整型数组！！！
}
public SeqList() //不带参数的构造方法
{
initiate(defaultSize);
}
public SeqList(int capacity) //带一个参数的构造方法
{
initiate(capacity);
}
//成员方法：清空线性表
public void clear()
{
this.size=0;
}
//实现 接口中定义的方法
public boolean isEmpty() //接口方法1：判断线性表是否为空
{
return this.size==0; //说明：==：是逻辑判断是否相等，如果相等返回值布尔值：真 true（1）,否则返回假 false 0
}
public void insert(int index ,int element) throws Exception //接口方法2：在线性表的指定位置插入数据元素
//加载异常事务处理方法
{
if(size==maxSize)
{
throw new Exception("顺序表已满，无法插入！"); //如果程序中需要将存在的异常事件抛出，则必须事先加载异常处理的方法
//抛出异常
}
if(index0 || indexsize)
{
throw new Exception("参数错误！");
}
for(int j=size;jindex;j--)
{
listArray[j]=listArray[j-1];
}
listArray[index]=element;
size++;
}
public int remove(int i) throws Exception //接口方法3：删除线性表中指定位置的数据元素
{
if(size==0)
{
throw new Exception("顺序表已空，无法删除！");
}
if(i0 || isize-1)
{
throw new Exception("参数错误！");
}
int it =listArray[i];
for(int j=i;jsize-1;j++)
{
listArray[j]=listArray[j+1];
}
size--;
return it; //将删除数据元素后新的数组??
}
//获取线性表中指定位置的数据元素
public int getData(int i) throws Exception //接口方法4：获取线性表中指定位置的数据元素
{
return listArray[i];
}
//求线性表的长度
public int length() //接口方法5：获取线性表的长度（数据元素的个数）
{
return size;
}
}
public class test { //定义public类：（1）在创建项目时指定的类
public static void main(String args[]) //（2）main方法应当在public类中
{
SeqList seqList = new SeqList(100);
//定义类的对象。在定义类的对象时，通过调用构造方法对类的成员变量进行赋值
//如果一个类中存在多个构造方法时，称为构造方法重载。
//调用构造方法时，由系统根据所调用的构造方法的参数个数和数据类型自动调用与之相匹配的构造方法
int n=10;
try //try语句中的内容是指：需要对程序运行的异常事件进行捕获
{
for(int i=0;i=n;i++)
{
seqList.insert(i,(i+1)); //通过类的对象调用类的成员方法
}
seqList.remove(4);
for(int i=0;in;i++)
{
System.out.println(seqList.getData(i)+" ");
}
//请在此添加判断线性表是否为空，如果为空，则提示用户线性表为空，否则输出线性表的长度
}
catch(Exception e) //catch语句的作用是：将try语句中捕获的异常内容抛出
{
System.out.println(e.getMessage());
}
}
}
如何在这程序中添加
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
int numLength = 10;
int deleteNum = 5;
ListInteger list = new ArrayListInteger();
init(numLength,list);
delete(deleteNum,list);
print(list);
}
private static void print(ListInteger list) {
for(int i=0;ilist.size();i++){
System.out.print(list.get(i) +"\t");
}
}
private static void delete(int deleteNum,ListInteger list) {
for (int i=0;ilist.size();i++){
if((int)list.get(i)==deleteNum){
list.remove(i);
}
}
}
private static void init(int numLength,ListInteger list) {
for(int i=1;i=numLength;i++){
list.add(i);
}
}
}
//当然你要是把你的代码贴上来就更好了，可以帮忙找出问题，另外也可以知道你对java了解到哪个程度了呵，给出的帮助可能更实际一些