第十周课上测试补做

第十周课上测试补做

一、相关知识点的总结

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编程完成以下功能：

1. 在测试类StudentTest中新建学生列表，包括自己和学号前后各两名学生，共5名学生,给出运行结果（排序前，排序后）
2. 对这5名同学分别用学号和总成绩进行增序排序，提交两个Comparator的代码
3. 课下提交代码到码云

分析：因为题目中属于多种排序，所以，要新建一个类，并让类实现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分析：

Example15_2.java

这个程序主要讲的是链表的遍历，值得学习的是：
利用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分析：

Example15_3.java

该程序的亮点是利用add(Object obj)向链表中依次添加结点
利用get()获取一个结点中的对象时，要用类型转换运算符转换回原来的类型。

关键代码分析：

Iterator iter=mylist.iterator();//获取针对mylist链表的迭代器
while(iter.hasNext()) {
    String te=(String)iter.next();  //必须强制转换取出的数据
    System.out.println(te);
}  

4.Example15_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分析：

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分析：

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分析：

Example15_8.java

本程序体现了用树集存放时，如果对象不是字符串类型，要重写compareTo方法规定排序方法。本程序中，贵司能够排序为按照英语成绩，所以，在树集中的存放方式要按照英语成绩存放。

9.Example15_9分析：

Example15_9.java

本程序主要是创建树映射，并存储关键字/值对，重写compareTo方法，然后分别对该树中的结点按英语成绩和数学成绩排序。

10.Example15_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+"元");
       }
     }
 }