第十周课上测试补做
Posted 20165203-xyx
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第十周课上测试补做相关的知识,希望对你有一定的参考价值。
第十周课上测试补做
一、相关知识点的总结
1.++链表++:由若干个称作结点的==对象==组成的一种数据结构,每个结点含有一个数据和下一个结点的引用,或含有一个数据并含有上一个结点的引用和下一个结点的引用。
2.创建链表:用java.util
包中的```LinkedList
LinkedList<String> mylist = new LinkedList<String>();
3.添加结点:add(E obj)
例如:mylist.add("How")
4.常用方法
5.遍历链表:
- 用++迭代器++遍历集合:链表对象用
iterator()
方法获得一个Iterator
对象. - 用
get(int index)
方法返回列表中的第index个对象。
6.排序与查找:
public static sort(List<E> list)
:将list中的元素按升序排列。
int binarySearch(List<T> list, T key, CompareTo<T> c)
:使用折半法查找list是否含有和参数key相等的元素,如果key与链表中的某个元素相等,方法返回和key相等的元素在链表中的索引位置(从0开始),否则返回-1.
- 链表中存放的对象是
String
类数据:则字符串按字典序比较大小
- 链表中存放的对象不是字符串数据:创建对象的类必须实现
Comparable
接口,即实现该接口中的方法int compareTo(Object b)
来规定对象的大小关系。
二、课上内容的补做,结果截图
课上题目2:
在数据结构和算法中,排序是很重要的操作,要让一个类可以进行排序,有两种方法:
- 有类的源代码,针对某一成员变量排序,让类实现Comparable接口,调用Collection.sort(List)
- 没有类的源代码,或者多种排序,新建一个类,实现Comparator接口,调用Collection.sort(List, Compatator)
针对下面的Student类,使用Comparator编程完成以下功能:
- 在测试类StudentTest中新建学生列表,包括自己和学号前后各两名学生,共5名学生,给出运行结果(排序前,排序后)
- 对这5名同学分别用学号和总成绩进行增序排序,提交两个Comparator的代码
- 课下提交代码到码云
分析:因为题目中属于多种排序,所以,要新建一个类,并让类实现Comparator接口,并重写接口中的int ComparaTo(Object b)
方法。
课题代码:代码
代码:
import java.util.*;
import java.text.*;
//重写接口中Compare方法
class Compare1 implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Student st1 = (Student)o1;
Student st2 = (Student)o2;
int id1 = Integer.parseInt(((Student) o1).getId());
int id2 = Integer.parseInt(((Student) o2).getId());
return (id1 - id2);
}
}
class Compare2 implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Student st1 = (Student) o1;
Student st2 = (Student) o2;
if (st1.getTotalScore() == st2.getTotalScore()) {
return 0;
}
if (st1.getTotalScore() > st2.getTotalScore()) {
return 1;
}
if (st1.getTotalScore() <= st2.getTotalScore()) {
return -1;
}
return 0;
}
}
class StudentTest {
public static void main(String[] args) {
List<Student> list = new LinkedList<Student>();//创建一个list链表
//向链表中添加结点(对象)
list.add(new Student("20165201", "李梓豪",90,91,95));
list.add(new Student("20165202", "贾海粟",89,93,92));
list.add(new Student("20165203", "夏云霄",93,95,92));
list.add(new Student("20165204", "贾普涵",88,90,91));
list.add(new Student("20165205", "刘喆君",87,90,92));
Iterator<Student> iter = list.iterator();//list链表对象用iterator方法获取一个Iterator对象(针对当前链表的迭代器)
System.out.println("排序前,链表中的数据");
while (iter.hasNext()) {
Student stu = iter.next();
System.out.println(stu.getId() + " " + stu.getName() + " 总成绩:" + stu.getTotalScore());
}
Collections.sort(list,new Compare1());//调用接口中的Compare1方法来就id来排序
System.out.println("按学号排序后,链表中的数据");
iter = list.iterator();
while (iter.hasNext()){
Student stu = iter.next();
System.out.println(stu.getId() + " " + stu.getName() + " 总成绩:" + stu.getTotalScore());
}
Collections.sort(list,new Compare2());//调用接口中的Compare2方法来就总分来排序
System.out.println("按总成绩排序后,链表中的数据");
iter = list.iterator();
while (iter.hasNext()){
Student stu = iter.next();
System.out.println(stu.getId() + " " + stu.getName() + " 总成绩:" + stu.getTotalScore());
}
}
}
class Student {
private char sex;
private String id;//表示学号
private String name;//表示姓名
private int age;//表示年龄
private double computer_score;//表示计算机课程的成绩
private double english_score;//表示英语课的成绩
private double maths_score;//表示数学课的成绩
private double total_score;// 表示总成绩
private double ave_score; //表示平均成绩
public Student(String id, String name) {
this.id = id;
this.name = name;
}
public Student(String id, String name, char sex, int age) {
this(id, name);
this.sex = sex;
this.age = age;
}
public Student(String id, String name, double computer_score, double english_score, double maths_score) {
this(id, name);
this.computer_score = computer_score;
this.english_score = english_score;
this.maths_score = maths_score;
}
public String getName() {
return name;
}
public String getId() {
return id;
}//获得当前对象的学号,
public double getComputer_score() {
return computer_score;
}//获得当前对象的计算机课程成绩,
public double getMaths_score() {
return maths_score;
}//获得当前对象的数学课程成绩,
public double getEnglish_score() {
return english_score;
}//获得当前对象的英语课程成绩,
public void setId(String id) {
this.id = id;
}// 设置当前对象的id值,
public void setComputer_score(double computer_score) {
this.computer_score = computer_score;
}//设置当前对象的Computer_score值,
public void setEnglish_score(double english_score) {
this.english_score = english_score;
}//设置当前对象的English_score值,
public void setMaths_score(double maths_score) {
this.maths_score = maths_score;
}//设置当前对象的Maths_score值,
public double getTotalScore() {
return computer_score + maths_score + english_score;
}// 计算Computer_score, Maths_score 和English_score 三门课的总成绩。
public double getAveScore() {
return getTotalScore() / 3;
}// 计算Computer_score, Maths_score 和English_score 三门课的平均成绩。
}
class Undergraduate extends Student {
private String classID;
public Undergraduate(String id, String name, char sex, int age, String classID) {
super(id, name, sex, age);
this.classID = classID;
}
public String getClassID() {
return classID;
}
public void setClassID(String classID) {
this.classID = classID;
}
}
结果截图:
课上题目3:
参见附件,补充MyList.java的内容,提交运行结果截图(全屏)
课下推送代码到码云
课题代码:代码
代码:
import java.util.*;
public class MyList {
public static void main(String [] args) {
List<String> list=new LinkedList<String>();
list.add("20165201");
list.add("20165202");
list.add("20165204");
list.add("20165205");
System.out.println("打印初始链表");
//把上面四个节点连成一个没有头结点的单链表
Iterator<String> iter=list.iterator();
while(iter.hasNext()){
String te=iter.next();
System.out.println(te);
}
//遍历单链表,打印每个结点的
list.add("20165203");
//把你自己插入到合适的位置(学号升序)
System.out.println("插入我的学号后排序,打印链表");
Collections.sort(list);
iter=list.iterator();
while(iter.hasNext()){
String te=iter.next();
System.out.println(te);
}
//遍历单链表,打印每个结点的
list.remove("20165203");
//从链表中删除自己
System.out.println("删除我的学号后打印链表");
iter=list.iterator();
while(iter.hasNext()){
String te=iter.next();
System.out.println(te);
}
//遍历单链表,打印每个结点的
}
}
结果截图:
分析:本例中添加了插入、排序、删除等内容,自己在做插入时,却在“如何插入到正确位置”这个位置上犯了难。 后来,自己经过思考,发现该链表中的结点都是String
类,String
类中实现了Comparable接口
,Collection调用sort排序时,字符串按字典序比较大小,不用重写compareTo方法。
三、教材第十五章的代码分析
1.Example15_1系列代码分析:
Cone.java
Rect.java
Circle.java
Example15_1.java
这个程序范例很好,帮助我理解了泛型类的概念,Cone.java表示的是计算一个椎体的体积,因为底面的形状不确定,所以,可用泛型类表示底面。之后又定义了Rect.java(计算矩形的面积),Circle.java(计算圆的面积),来在主程序中计算椎体的体积。
2.Example15_2分析:
这个程序主要讲的是链表的遍历,值得学习的是:
利用Iterator<String> iter = list.iterator();
创建了一个针对list链表的迭代器。
自己对程序中不懂的代码进行了学习:
iter.hasNext()
:该语句的作用是判断链表中下一个结点是否是空结点,如果不是返回true,是返回fale,可用于循环语句中。iter.next()
:该语句也是用来判断列表中下一个结点是否是空结点,如果不是,返回下一个结点.
关键代码分析:
Iterator<String> iter=list.iterator();//创建一个iter链表迭代器
long starttime=System.currentTimeMillis();//以毫秒为单位计算开始使的时间
//遍历整个链表,将链表中的节点赋给te数组
while(iter.hasNext()){
String te=iter.next();
}
3.Example15_3分析:
该程序的亮点是利用add(Object obj)
向链表中依次添加结点
利用get()
获取一个结点中的对象时,要用类型转换运算符转换回原来的类型。
关键代码分析:
Iterator iter=mylist.iterator();//获取针对mylist链表的迭代器
while(iter.hasNext()) {
String te=(String)iter.next(); //必须强制转换取出的数据
System.out.println(te);
}
4.Example15_4分析:
这个程序的功能是排序,让我学到了不少东西。
该程序中链表中存放的Studnet类对象并不是字符串型的,所以,要让Studnet类实现Comparable接口,实现该接口中的compare To(Object b)方法。
程序:
public int compareTo(Object b) { // 两个Student对象相等当且仅当二者的height值相等
Student st=(Student)b;
return (this.height-st.height);
}
给出了排序的根据:两个结点相等的根据是对象的height相等。height值大的排在后面。
关键代码分析:
//通过重写compareTo方法规定排序的依据
class Student implements Comparable {
int height=0;
String name;
Student(String n,int h) {
name=n;
height = h;
}
public int compareTo(Object b) { // 两个Student对象相等当且仅当二者的height值相等
Student st=(Student)b;
return (this.height-st.height);
}
}
5.Example15_5分析:
该程序主要体现了洗牌,所谓洗牌就是将链表中的数据重新随机排列,可用public static void shuffle(List<E> list)
static void rotate(List<E> list, int distance)
:distance取正值,向右转动;distance取负值,向左转动。
public static void reverse(List<E> list)
:翻转list中的数据。
关键代码分析:
Collections.shuffle(list);//洗牌后的重新操作
Collections.rotate(list,1);//向右旋转1次后的操作
6.Example15_6分析:
该程序主要是创建了一个堆栈对象stack,并在stack中放入对象,然后输出该递归序列的若干项.
关键代码分析:
Stack<Integer> stack=new Stack<Integer>();//创建一个堆栈对象
//向堆栈中放入对象,注意堆栈中的元素是对象
stack.push(new Integer(1));
stack.push(new Integer(1));
int f1=F1.intValue();//吧Integer类型转化为int类型
7.Example15_7分析:
Example15_7.java
WindowWord.java
WordPolice.java
本程序主要体现散列映射的意义,主要是存储数据便于查找,该程序就是用WordPolice类使用Scanner解析word.txt中的单词,并将英文单词/汉语对应键/值存储到散列映射中供用户查询。
8.Example15_8分析:
本程序体现了用树集存放时,如果对象不是字符串类型,要重写compareTo方法规定排序方法。本程序中,贵司能够排序为按照英语成绩,所以,在树集中的存放方式要按照英语成绩存放。
9.Example15_9分析:
本程序主要是创建树映射,并存储关键字/值对,重写compareTo方法,然后分别对该树中的结点按英语成绩和数学成绩排序。
10.Example15_10分析:
该程序体现了自动装箱和自动拆箱。将链表中的int型数据转换成Integer对象,输出时,将Integer对象转换成int类型。
四、第15章课下编程题
1.使用堆栈结构输出an的若干项,其中an=2an-1+2an-1,a1=3,a2=8
分析:编程思路如下:
- 定义堆栈
- 将数列前两项放入堆栈
- 计算第三项,依次循环
代码如下:
import java.util.*;
public class Exp1 {
public static void main(String args[]) {
Stack<Integer> stack = new Stack<Integer>();//定义一个空堆栈
//将数列前两项放入堆栈中
stack.push(3);
stack.push(8);
int k = 1;
//输出15项
while (k <= 15) {
for (int i = 1; i <= 2; i++) {
Integer F1=stack.pop();
int f1 = F1.intValue();
Integer F2=stack.pop();
int f2 = F2.intValue();
Integer temp = 2*f1+2*f2;
System.out.println(" "+temp.toString());
stack.push(temp);
stack.push(F2);
k++;
}
}
}
}
2.编写一个程序,将链表中的学生英语成绩单存放到一个树集中,使得按成绩自动排序,并输出排序结果。
代码:
import java.util.*;
import static java.sql.DriverManager.println;
class College implements Comparable {
int english=0;
String name;
College(String name, int english ){
this.name=name;
this.english=english;
}
public int comparaTo(Object b) {
College stu = (College) b;
return (this.english-stu.english);
}
}
public class Exp2 {
public static void main(String args[]) {
List<College> list=new LinkedList<College>();
int score [] = {85,88,90,91,88};
String name [] = {"李梓豪","贾海粟","夏云霄","贾普涵","刘喆君"};
for(int i=0; i<score.length;i++){
list.add(new College(name[i],score[i]));
}
Iterator<College> iter = list.iterator();
TreeSet<College> mytree=new TreeSet<College>();
while(iter.hasNext()) {
College stu=iter.next();
mytree.add(stu);
}
Iterator<College> te=mytree.iterator();
while(te.hasNext()) {
College stu = iter.next();
System.out.println(""+stu.name+" "+stu.english);
}
}
}
3.3、有10个U盘,有两个重要的属性:价格和容量。编写一个应用程序,使用TreeMap
import java.util.*;
class SandyKey implements Comparable {
double key=0;
SandyKey(double d) {
key=d;
}
public int compareTo(Object b) {
SandyKey disc=(SandyKey)b;
if((this.key-disc.key)==0)
return -1;
else
return (int)((this.key-disc.key)*1000);
}
}
class Sandy{
int amount;
double price;
Sandy(int m,double e) {
amount=m;
price=e;
}
}
public class E {
public static void main(String args[ ]) {
TreeMap<SandyKey,Sandy> treemap= new TreeMap<SandyKey,Sandy>();
int amount[]={1,2,4,8,16};
double price[]={867,266,390,556};
Sandy Sandy[]=new Sandy[4];
for(int k=0;k<Sandy.length;k++) {
Sandy[k]=new Sandy(amount[k],price[k]);
}
SandyKey key[]=new SandyKey[4];
for(int k=0;k<key.length;k++) {
key[k]=new SandyKey(Sandy[k].amount); }
for(int k=0;k<Sandy.length;k++) {
treemap.put(key[k],Sandy[k]); }
int number=treemap.size();
Collection<Sandy> collection=treemap.values();
Iterator<Sandy> iter=collection.iterator();
while(iter.hasNext()) {
Sandy sandy=iter.next();
System.out.println(""+sandy.amount+"G "+sandy.price+"元"); }
treemap.clear();
for(int k=0;k<key.length;k++) {
key[k]=new SandyKey(Sandy[k].price); }
for(int k=0;k<Sandy.length;k++) {
treemap.put(key[k],Sandy[k]); }
number=treemap.size();
collection=treemap.values();
iter=collection.iterator();
while(iter.hasNext()) {
Sandy sandy=iter.next();
System.out.println(""+sandy.amount+"G "+sandy.price+"元");
}
}
}
以上是关于第十周课上测试补做的主要内容,如果未能解决你的问题,请参考以下文章