第十周课上测试补做

第十周课上测试补做

一、相关知识点的总结

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+"元");
       }
     }
 }
posted @ 2018-05-06 11:22  I~Justice  阅读(330)  评论(0编辑  收藏  举报