一、关于数据结构方面
数据结构是计算机存储，组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或存储效率。数据结构往往同高效的检索算法和索引技术有关。（来源于百度百科）
主要讲了数据的逻辑结构和储存结构。同时，在算法上也进行了部分的讲解，学习了算法的时间复杂度和空间复杂度。
二、线性表
线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。
1.线性表的顺序存储结构——顺序表
public class SqListClass<E> { //顺序表泛型类
final int initcapacity = 10; //顺序表的初始容量(常量)
public E[] data; //存放顺序表中元素
public int size; //存放顺序表的长度
private int capacity; //存放顺序表的容量
public SqListClass() { //构造方法，实现data和length的初始化
data = (E[]) new Object[initcapacity]; //强制转换为E类型数组
capacity = initcapacity;
size = 0;
}
//线性表的基本运算算法
public void CreateList(E[] a) { //由a整体建立顺序表
size = 0;
for (E e : a) {
if (size == capacity) { //出现上溢出时
updateCapacity(2 * size); //扩大容量
}
data[size] = e;
size++; //添加的元素个数增加1
}
}
public void Add(E e) { //在线性表的末尾添加一个元素e
if (size == capacity) { //顺序表空间满时倍增容量
updateCapacity(2 * size);
}
data[size] = e;
size++; //长度增1
}
public int size() { // 求线性表长度
return size;
}
public void Setsize(int nlen) { //设置线性表的长度
if (nlen < 0 || nlen > size) {
throw new IllegalArgumentException("设置长度:n不在有效范围内");
}
size = nlen;
}
public E GetElem(int i) { //返回线性表中序号为i的元素
if (i < 0 || i > size - 1) {
throw new IllegalArgumentException("查找:位置i不在有效范围内");
}
return (E) data[i];
}
public void SetElem(int i, E e) { //设置序号i的元素为e
if (i < 0 || i > size - 1) {
throw new IllegalArgumentException("设置:位置i不在有效范围内");
}
data[i] = e;
}
public int GetNo(E e) { //查找第一个为e的元素的序号
int i = 0;
while (i < size && !data[i].equals(e)) {
i++; //查找元素e
}
if (i >= size) { //未找到时返回-1
return -1;
} else {
return i; //找到后返回其序号
}
}
public void swap(int i, int j) { //交换data[i]和data[j]
E tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
public void Insert(int i, E e) { //在线性表中序号i位置插入元素e
if (i < 0 || i > size) { //参数错误抛出异常
throw new IllegalArgumentException("插入:位置i不在有效范围内");
}
if (size == capacity) { //满时倍增容量
updateCapacity(2 * size);
}
for (int j = size; j > i; j--) { //data[i]及后面元素后移一个位置
data[j] = data[j - 1];
}
data[i] = e; //插入元素e
size++; //顺序表长度增1
}
public void Delete(int i) { //在线性表中删除序号i位置的元素
if (i < 0 || i > size - 1) { //参数错误抛出异常
throw new IllegalArgumentException("删除:位置i不在有效范围内");
}
for (int j = i; j < size - 1; j++) { //将data[i]之后的元素前移一个位置
data[j] = data[j + 1];
}
size--; //顺序表长度减1
if (capacity > initcapacity && size == capacity / 4) {
updateCapacity(capacity / 2); //满足要求容量减半
}
}
@Override
public String toString() { //将线性表转换为字符串
String ans = "";
for (int i = 0; i < size; i++) {
ans += data[i].toString() + " ";
}
return ans;
}
private void updateCapacity(int newCapacity) { //改变顺序表的容量为newCapacity
E[] newData = (E[]) new Object[newCapacity];
for (int i = 0; i <size; i++) {
newData[i] = data[i];
}
capacity = newCapacity; //设置新容量
data = newData; //仍由data标识数组
}
}2.线性表的链式存储结构——链表
单链表
class LinkNode<E>{
E data;
LinkNode<E>next;
public LinkNode(){
next=null;
}public LinkNode(E d){
data=d;
next=null;
}
}关于单链表的算法设计及各种结点操作
public class LinkListClass<E> {
public LinkNode<E> head;
public LinkListClass() {
head = new LinkNode<E>();
head.next = null;
}
public int size() {
LinkNode<E> p = head;
int cnt = 0;
while (p.next != null) {
cnt++;
p = p.next;
}
return cnt;
}
public void CreatListF(E[] a) {
LinkNode<E> s;
for (int i = 0; i < a.length; i++) {
s = new LinkNode<E>(a[i]);
s.next = head.next;
head.next = s;
}
}
public void CreateListR(E[] a) {
LinkNode<E> s, t = head;
for (int i = 0; i < a.length; i++) {
s = new LinkNode<E>(a[i]);
t.next = s;
t = s;
}
t.next = null;
}
private LinkNode<E> geti(int i) {
LinkNode<E> p = head;
int j = -1;
while (j < i) {
j++;
p = p.next;
}
return p;
}
public void Add(E e) {
LinkNode<E> s = new LinkNode<E>(e);
LinkNode<E> p = head;
while (p.next != null)
p = p.next;
p.next = s;
}
public E GetElem(int i) {
int len = size();
if (i < 0 || i > len - 1)
throw new IllegalArgumentException("查找：位置i不在有效范围内");
LinkNode<E> p = geti(i);
return (E) p.data;
}
public void Setsize(int nlen) {
int len = size();
if (nlen < 0 || nlen > len)
throw new IllegalArgumentException("设置长度：n不在有效范围内");
if (nlen == len)
return;
LinkNode<E> p = geti(nlen - 1);
p.next = null;
}
public void Insert(int i, E e) {
if (i < 0 || i > size())
throw new IllegalArgumentException("插入：位置i不在有效范围内");
LinkNode<E> s = new LinkNode<E>(e);
LinkNode<E> p = geti(i - 1);
s.next = p.next;
p.next = s;
}
public void Delete(int i) {
if (i < 0 || i > size() - 1)
throw new IllegalArgumentException("删除：位置i不在有效范围内");
LinkNode<E> p = geti(i - 1);
p.next = p.next.next;
}
public void SetElem(int i, E e) {
if (i < 0 || i > size() - 1)
throw new IllegalArgumentException("设置：位置i不在有效范围内");
LinkNode<E> p = geti(i);
p.data = e;
}
public int GetNo(E e) {
int j = 0;
LinkNode<E> p = head.next;
while (p != null && !p.data.equals(e)) {
j++;
p = p.next;
}
if (p == null)
return -1;
else return j;
}
public void swap(int i, int j) {
LinkNode<E> p = geti(i);
LinkNode<E> q = geti(j);
E tmp = p.data;
p.data = q.data;
q.data = tmp;
}
public String toString() {
String ans = "";
LinkNode<E> p = head.next;
while (p != null) {
ans += p.data + "";
p = p.next;
}
return ans;
}
class DLinkNote<E>{
E date;
DLinkNote<E> prior;
DLinkNote<E> next;
public DLinkNote(){
prior=null;
next=null;
}
public DLinkNote(E d){
date=d;
prior=null;
next=null;
}
}
}双链表
class DLinkNode<E> //双链表结点泛型类
{
E data;
DLinkNode<E> prior; //前驱结点指针
DLinkNode<E> next; //后继结点指针
public DLinkNode() //构造方法
{
prior=null;
next=null;
}
public DLinkNode(E d) //重载构造方法
{
data=d;
prior=null;
next=null;
}
}
public class DLinkListClass<E> //双链表泛型类
{
DLinkNode<E> dhead; //存放头结点
public DLinkListClass() //构造方法
{
dhead=new DLinkNode<E>(); //创建头结点
dhead.prior=null;
dhead.next=null;
}
private DLinkNode<E> geti(int i) //返回序号为i的结点
{
DLinkNode<E> p=dhead;
int j=-1;
while (j<i)
{
j++;
p=p.next;
}
return p;
}
//线性表的基本运算算法
public void CreateListF(E[] a) //头插法：由数组a整体建立双链表
{
DLinkNode<E> s;
for (int i=0;i<a.length;i++) //循环建立数据结点s
{
s=new DLinkNode<E>(a[i]); //新建存放a[i]元素的结点s，将其插入到表头
s.next=dhead.next; //修改s结点的next字段
if (dhead.next!=null) //修改头结点的非空后继结点的prior字段
dhead.next.prior=s;
dhead.next=s; //修改头结点的next字段
s.prior=dhead; //修改s结点的prior字段
}
}
public void CreateListR(E[] a) //尾插法：由数组a整体建立双链表
{
DLinkNode<E> s,t;
t=dhead; //t始终指向尾结点,开始时指向头结点
for (int i=0;i<a.length;i++) //循环建立数据结点s
{ s=new DLinkNode<E>(a[i]); //新建存放a[i]元素的结点s
t.next=s; //将s结点插入t结点之后
s.prior=t; t=s;
}
t.next=null; //将尾结点的next字段置为null
}
public void Add(E e) //在线性表的末尾添加一个元素e
{
DLinkNode<E> s=new DLinkNode<E>(e); //新建结点s
DLinkNode<E> p=dhead;
while (p.next!=null) //查找尾结点p
p=p.next;
p.next=s; //在尾结点之后插入结点s
s.prior=p;
}
public int size() //求线性表长度
{
DLinkNode<E> p=dhead;
int cnt=0;
while (p.next!=null) //找到尾结点为止
{
cnt++;
p=p.next;
}
return cnt;
}
public void Setsize(int nlen) //设置线性表的长度
{
int len=size();
if (nlen<0 || nlen>len)
throw new IllegalArgumentException("设置长度:n不在有效范围内");
if (nlen==len) return;
DLinkNode<E> p=geti(nlen-1); //找到序号为nlen-1的结点p
p.next=null; //将结点p置为尾结点
}
public E GetElem(int i) //返回线性表中序号为i的元素
{
int len=size();
if (i<0 || i>len-1)
throw new IllegalArgumentException("查找:位置i不在有效范围内");
DLinkNode<E> p=geti(i); //找到序号为i的结点p
return (E)p.data;
}
public void SetElem(int i,E e) //设置序号i的元素为e
{
if (i<0 || i>size()-1)
throw new IllegalArgumentException("设置:位置i不在有效范围内");
DLinkNode<E> p=geti(i); //找到序号为i的结点p
p.data=e;
}
public int GetNo(E e) //查找第一个为e的元素的序号
{
int j=0;
DLinkNode<E> p=dhead.next;
while (p!=null && !p.data.equals(e))
{
j++; //查找元素e
p=p.next;
}
if (p==null) //未找到时返回-1
return -1;
else
return j; //找到后返回其序号
}
public void Insert(int i, E e) //在线性表中序号i位置插入元素e
{
if (i<0 || i>size()) //参数错误抛出异常
throw new IllegalArgumentException("插入:位置i不在有效范围内");
DLinkNode<E> s=new DLinkNode<E>(e); //建立新结点s
DLinkNode<E> p=dhead=geti(i-1); //找到序号为i-1的结点p,其后插入s结点
s.next=p.next; //修改s结点的next字段
if (p.next!=null) //修改p结点的非空后继结点的prior字段
p.next.prior=s;
p.next=s; //修改p结点的next字段
s.prior=p; //修改s结点的prior字段
}
public void Delete(int i) //在线性表中删除序号i位置的元素
{
if (i<0 || i>size()-1) //参数错误抛出异常
throw new IllegalArgumentException("删除:位置i不在有效范围内");
DLinkNode<E> p=geti(i); //找到序号为i的结点p,删除该结点
p.prior.next=p.next; //修改p结点的前驱结点的next字段
if (p.next!=null) //修改p结点非空后继结点的prior字段
p.next.prior=p.prior;
}
public String toString() //将线性表转换为字符串
{
String ans="";
DLinkNode<E> p=dhead.next;
while (p!=null)
{
ans+=p.data+" ";
p=p.next;
}
return ans;
}
}循环链表
class LinkNode<E> //循环单链表结点泛型类
{
E data;
LinkNode<E> next;
public LinkNode() { //构造方法
next=null;
}
public LinkNode(E d) //重载构造方法
{
data=d;
next=null;
}
}
public class CLinkListClass<E> //循环单链表泛型类
{
LinkNode<E> head; //存放头结点
public CLinkListClass() //构造方法
{
head=new LinkNode<E>(); //创建头结点
head.next=head; //置为空的循环单链表
}
private LinkNode<E> geti(int i) //返回序号为i的结点
{
LinkNode<E> p=head;
int j=-1;
while (j<i)
{
j++;
p=p.next;
}
return p;
}
//线性表的基本运算算法
public void CreateListF(E[] a) //头插法：由数组a整体建立循环单链表
{
LinkNode<E> s;
for (int i=0;i<a.length;i++) //循环建立数据结点s
{
s=new LinkNode<E>(a[i]); //新建存放a[i]元素的结点s
s.next=head.next; //将s结点插入到开始结点之前,头结点之后
head.next=s;
}
}
public void CreateListR(E[] a) //尾插法：由数组a整体建立循环单链表
{
LinkNode<E> s,t;
t=head; //t始终指向尾结点,开始时指向头结点
for (int i=0;i<a.length;i++) //循环建立数据结点s
{
s=new LinkNode<E>(a[i]); //新建存放a[i]元素的结点s
t.next=s; //将s结点插入t结点之后
t=s;
}
t.next=head; //将尾结点的next字段置为head
}
public void Add(E e) //在线性表的末尾添加一个元素e
{
LinkNode<E> s=new LinkNode<E>(e); //新建结点s
LinkNode<E> p=head;
while (p.next!=head) //查找尾结点p
p=p.next;
p.next=s; //在尾结点之后插入结点s
s.next=head;
}
public int size() //求线性表长度
{
LinkNode<E> p=head;
int cnt=0;
while (p.next!=head) //找到尾结点为止
{
cnt++;
p=p.next;
}
return cnt;
}
public void Setsize(int nlen) //设置线性表的长度
{
int len=size();
if (nlen<0 || nlen>len)
throw new IllegalArgumentException("设置长度:n不在有效范围内");
if (nlen==len) return;
LinkNode<E> p=geti(nlen-1); //找到序号为nlen-1的结点p
p.next=head; //将结点p置为尾结点
}
public E GetElem(int i) //返回线性表中序号为i的元素
{
int len=size();
if (i<0 || i>len-1)
throw new IllegalArgumentException("查找:位置i不在有效范围内");
LinkNode<E> p=geti(i); //找到序号为i的结点p
return (E)p.data;
}
public void SetElem(int i,E e) //设置序号i的元素为e
{
if (i<0 || i>size()-1)
throw new IllegalArgumentException("设置:位置i不在有效范围内");
LinkNode<E> p=geti(i); //找到序号为i的结点p
p.data=e;
}
public int GetNo(E e) //查找第一个为e的元素的序号
{
int j=0;
LinkNode<E> p=head.next;
while (p!=head && !p.data.equals(e))
{
j++; //查找元素e
p=p.next;
}
if (p==head) //未找到时返回-1
return -1;
else
return j; //找到后返回其序号
}
public void Insert(int i, E e) //在线性表中序号i位置插入元素e
{
if (i<0 || i>size()) //参数错误抛出异常
throw new IllegalArgumentException("插入:位置i不在有效范围内");
LinkNode<E> s=new LinkNode<E>(e); //建立新结点s
LinkNode<E> p=head=geti(i-1); //找到序号为i-1的结点p
s.next=p.next; //在p结点后面插入s结点
p.next=s;
}
public void Delete(int i) //在线性表中删除序号i位置的元素
{
if (i<0 || i>size()-1) //参数错误抛出异常
throw new IllegalArgumentException("删除:位置i不在有效范围内");
LinkNode<E> p=geti(i-1); //找到序号为i-1的结点p
p.next=p.next.next; //删除p结点的后继结点
}
public String toString() //将线性表转换为字符串
{
String ans="";
LinkNode<E> p=head.next;
while (p!=head)
{
ans+=p.data+" ";
p=p.next;
}
return ans;
}
}循环双链表
class DLinkNode<E> //循环双链表结点泛型类
{
E data;
DLinkNode<E> prior; //前驱结点指针
DLinkNode<E> next; //后继结点指针
public DLinkNode() //构造方法
{
prior=null;
next=null;
}
public DLinkNode(E d) //重载构造方法
{
data=d;
prior=null;
next=null;
}
}
public class CDLinkListClass<E> //循环双链表泛型类
{
DLinkNode<E> dhead; //存放头结点
public CDLinkListClass() //构造方法
{
dhead=new DLinkNode<E>(); //创建头结点
dhead.prior=dhead; //构成空的循环双链表
dhead.next=dhead;
}
private DLinkNode<E> geti(int i) //返回序号为i的结点
{
DLinkNode<E> p=dhead;
int j=-1;
while (j<i)
{
j++;
p=p.next;
}
return p;
}
//线性表的基本运算算法
public void CreateListF(E[] a) //头插法：由数组a整体建立循环双链表
{
DLinkNode<E> s;
for (int i=0;i<a.length;i++) //循环建立数据结点s
{
s=new DLinkNode<E>(a[i]); //新建存放a[i]元素的结点s
s.next=dhead.next; //修改s结点的next字段
dhead.next.prior=s;
dhead.next=s; //修改头结点的next字段
s.prior=dhead; //修改s结点的prior字段
}
}
public void CreateListR(E[] a) //尾插法：由数组a整体建立循环双链表
{
DLinkNode<E> s,t;
t=dhead; //t始终指向尾结点,开始时指向头结点
for (int i=0;i<a.length;i++) //循环建立数据结点s
{ s=new DLinkNode<E>(a[i]); //新建存放a[i]元素的结点s
t.next=s; //将s结点插入t结点之后
s.prior=t; t=s;
}
t.next=dhead; //将尾结点的next字段置为head
dhead.prior=t; //将头结点的prior字段置为t
}
public void Add(E e) //在线性表的末尾添加一个元素e
{
DLinkNode<E> s=new DLinkNode<E>(e); //新建结点s
DLinkNode<E> p=dhead;
while (p.next!=dhead) //查找尾结点p
p=p.next;
p.next=s; //在尾结点p之后插入结点s
s.prior=p;
s.next=dhead;
dhead.prior=s;
}
public int size() //求线性表长度
{
DLinkNode<E> p=dhead;
int cnt=0;
while (p.next!=dhead) //找到尾结点为止
{
cnt++;
p=p.next;
}
return cnt;
}
public void Setsize(int nlen) //设置线性表的长度
{
int len=size();
if (nlen<0 || nlen>len)
throw new IllegalArgumentException("设置长度:n不在有效范围内");
if (nlen==len) return;
DLinkNode<E> p=geti(nlen-1); //找到序号为nlen-1的结点p
p.next=dhead; //将结点p置为尾结点
dhead.prior=p;
}
public E GetElem(int i) //返回线性表中序号为i的元素
{
int len=size();
if (i<0 || i>len-1)
throw new IllegalArgumentException("查找:位置i不在有效范围内");
DLinkNode<E> p=geti(i); //找到序号为i的结点p
return (E)p.data;
}
public void SetElem(int i,E e) //设置序号i的元素为e
{
if (i<0 || i>size()-1)
throw new IllegalArgumentException("设置:位置i不在有效范围内");
DLinkNode<E> p=geti(i); //找到序号为i的结点p
p.data=e;
}
public int GetNo(E e) //查找第一个为e的元素的序号
{
int j=0;
DLinkNode<E> p=dhead.next;
while (p!=dhead && !p.data.equals(e))
{
j++; //查找元素e
p=p.next;
}
if (p==dhead) //未找到时返回-1
return -1;
else
return j; //找到后返回其序号
}
public void Insert(int i, E e) //在线性表中序号i位置插入元素e
{
if (i<0 || i>size()) //参数错误抛出异常
throw new IllegalArgumentException("插入:位置i不在有效范围内");
DLinkNode<E> s=new DLinkNode<E>(e); //建立新结点s
DLinkNode<E> p=dhead=geti(i-1); //找到序号为i-1的结点p,其后插入s结点
s.next=p.next; //修改s结点的next字段
p.next.prior=s;
p.next=s; //修改p结点的next字段
s.prior=p; //修改s结点的prior字段
}
public void Delete(int i) //在线性表中删除序号i位置的元素
{
if (i<0 || i>size()-1) //参数错误抛出异常
throw new IllegalArgumentException("删除:位置i不在有效范围内");
DLinkNode<E> p=geti(i); //找到序号为i的结点p,删除该结点
p.prior.next=p.next; //修改p结点的前驱结点的next字段
p.next.prior=p.prior;
}
public String toString() //将线性表转换为字符串
{
String ans="";
DLinkNode<E> p=dhead.next;
while (p!=dhead)
{
ans+=p.data+" ";
p=p.next;
}
return ans;
}
}链表容器
public class trans
{
public static void main(String[] args)
{
ArrayList<String> myarrlist = new ArrayList<String>();
myarrlist.add("A");
myarrlist.add("B");
myarrlist.add("C");
myarrlist.add("D");
System.out.println("ArrayList: "+myarrlist);
System.out.println("ArrayList->LinkedList");
LinkedList<String> mylinklist=new LinkedList<String>(myarrlist);
System.out.println("LinkedList: "+mylinklist);
System.out.println("清空LinkedList并添加1,2,3");
mylinklist.clear();
mylinklist.add("1");
mylinklist.add("2");
mylinklist.add("3");
System.out.println("LinkedList: "+mylinklist);
myarrlist=new ArrayList<String>(mylinklist);
System.out.println("LinkedList->ArrayList");
System.out.println("ArrayList: "+myarrlist);
}
}代码运行结果
求解多项式相加问题
class PolyElem //多项式顺序表元素类型
{ double coef; //系数
int exp; //指数
PolyElem(double c,int e) //构造方法
{
coef=c;
exp=e;
}
public int getexp() //用于按exp递减排序
{
return exp;
}
}
class PolyClass //多项式顺序表类
{ ArrayList<PolyElem> poly; //存放多项式顺序表
public PolyClass() //构造方法
{
poly=new ArrayList<PolyElem>(); //分配顺序表的data空间
}
public void Add(PolyElem p) //末尾添加一个多项式项
{
poly.add(p);
}
public void CreatePoly(double[] a,int[] b,int n) //建立多项式顺序表
{
for (int i=0;i<n;i++)
poly.add(new PolyElem(a[i],b[i]));
}
public void Sort() //对多项式顺序表按exp域递减排序
{
poly.sort(Comparator.comparing(PolyElem::getexp).reversed()); //comparingInt
}
public void DispPoly() //输出多项式顺序表
{ boolean first=true; //first为true表示是第一项
int i=0;
while (i<poly.size())
{
PolyElem p=(PolyElem)poly.get(i);
if (first) first=false;
else if (p.coef>0) System.out.print("+");
if (p.exp==0) //指数为0时不输出'x'
System.out.print(p.coef);
else if (p.exp==1) //指数为1时不输出指数
System.out.print(p.coef+"x");
else
System.out.print(p.coef+"x^"+p.exp);
i++;
}
System.out.println();
}
}
public class PolyTest1 {
public static PolyClass Add(PolyClass L1,PolyClass L2) //两个多项式相加运算
{ int i=0,j=0;
double c;
PolyClass L3=new PolyClass();
while (i<L1.poly.size() && j<L2.poly.size())
{ if (L1.poly.get(i).exp>L2.poly.get(j).exp) //L1的元素的指数较大
{
L3.Add(new PolyElem(L1.poly.get(i).coef,L1.poly.get(i).exp)); //新建L3的元素
i++;
}
else if (L1.poly.get(i).exp<L2.poly.get(j).exp) //L2的元素的指数较大
{
L3.Add(new PolyElem(L2.poly.get(j).coef,L2.poly.get(j).exp)); //新建L3的元素
j++;
}
else //两元素的指数相等
{ c=L1.poly.get(i).coef+L2.poly.get(j).coef; //求两指数相等元素的系数和
if (c!=0) //系数和c不为0时复制
L3.Add(new PolyElem(c,L1.poly.get(i).exp)); //新建L3的元素
i++; j++;
}
}
while (i<L1.poly.size()) //复制poly1余下的元素
{
L3.Add(new PolyElem(L1.poly.get(i).coef,L1.poly.get(i).exp)); //新建L3的元素
i++;
}
while (j<L2.poly.size()) //复制poly2余下的元素
{
L3.Add(new PolyElem(L2.poly.get(j).coef,L2.poly.get(j).exp)); //新建L3的元素
j++;
}
return L3;
}
public static void main(String[] args) throws FileNotFoundException
{
System.setIn(new FileInputStream("E:\\ideaCode\\shujujiegou\\src\\ch2\\Application\\abc.in")); //将标准输入流重定向至abc.in
Scanner fin = new Scanner(System.in);
//System.setOut(new PrintStream("E:\\ideaCode\\shujujiegou\\src\\ch2\\Application\\abc.out")); //将标准输出流重定向至abc.out
PolyClass L1=new PolyClass();
PolyClass L2=new PolyClass();
PolyClass L3; //建立3个多项式顺序表对象
double[] a=new double[100];
int[] b=new int[100];
int n;
n = fin.nextInt(); //输入n
for (int i=0;i<n;i++) //输入a
a[i]=fin.nextDouble();
for (int i=0;i<n;i++) //输入b
b[i]=fin.nextInt();
L1.CreatePoly(a,b,n); //创建第1个多项式顺序表
System.out.print("第1个多项式: "); L1.DispPoly();
L1.Sort(); //排序
System.out.print("排序后结果: "); L1.DispPoly();
n = fin.nextInt(); //输入n
for (int i=0;i<n;i++) //输入a
a[i]=fin.nextDouble();
for (int i=0;i<n;i++) //输入b
b[i]=fin.nextInt();
L2.CreatePoly(a,b,n); //创建第2个多项式顺序表
System.out.print("第2个多项式: "); L2.DispPoly();
L2.Sort(); //排序
System.out.print("排序后结果: "); L2.DispPoly();
L3=Add(L1,L2); //两多项式相加
System.out.print("相加后多项式: "); L3.DispPoly();
}
}代码运行结果
493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
