第十周课下补做

课程知识点总结

• 在数据结构和算法中，排序是很重要的操作，要让一个类可以进行排序，有两种方法：
  • Comparable：“可比较的”，（欲参与比较的对象对应的元素类需实现Comparable接口）
    使用这种策略来比较时，两个对象(这里两个对象是指一个类的两个不同实例)本身必须是“可比较的”，比较的标准由对象所在的类来定义，这种可比较的能力是对象本身固有的，因此不需要第三方参与就可以完成比较。要使得两个对象本身是可比较的，那么对象所在的类必须实现Comparable接口才可以,调用Collection.sort(List)。其compareTo()方法只要一个参数，因为这里只有“你”“我”的关系，没有第三方。
    比如，两个人要比较身高，分辨高矮是人类固有的能力，两个人只要站到一起就能分出谁高谁矮。
  • Comparator：“比较器”
    使用这种策略来比较时，如何进行比较和两个对象本身无关，而是由第三者（即比较器）来完成的。第三方比较器类需要另外专门设计:只要实现Comparator接口，任何一个类(对象)都可能成为一个“比较器”，但比较器并不是比较自己的实例，而是比较其它类的两个不同对象，比较器在这里充当“仲裁者”的角色，这也就是为什么compare()方法需要两个参数,调用Collection.sort(List, Compatator)。
    比如，两个人要比较谁智商更高，靠他们自身无法进行，这时要借助一个比较器（比如，智商测试题）。
• 泛型类声明:
  class 名称<泛型列表>
• 创建链表
  LinkedList<String> mylist=new LinkedList<String>();
• 向链表增加节点
  list.add(E obj);
• 从链表中删除节点
  list.remove(index)
• 升序排序
  public static sort(List<E>list)

• 折半查找list是否含有和参数key一样的元素
  int binarySearch(List<T>,Tkey,compareTo<T>c)
  ## 习题补做

  排序

• 代码链接

• 实验结果截图
  

单链表

• 代码链接
• 实验结果截图
  

第十五章教材代码分析

• Example15_1
• 初步接触、了解泛型。知道泛型类声明和创建对象时要用具体类型来替换“<>”中的泛型
  Cone<Circle> coneOne; coneOne = new Cone<Circle>(new
• 泛型中的泛型变量bottom只能调用Object类中的方法

第十五章课后编程题

（1）使用堆栈结构输出an的若干项，其中an=2an-1+2an-2，a1=3，a2=8

• 代码：

import java.util.*;
    public class T1 {
        public static void main(String[] args) {
            Stack<Integer> stack=new Stack<Integer>();
            stack.push(new Integer(3));
            stack.push(new Integer(8));
            int k=1;
            while (k<=10) {
                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.*;
class CollegeStu implements Comparable {
    int english=0;
    String name;
    CollegeStu(int english,String name) {
        this.name=name;
        this.english=english;
    }
    @Override
    public int compareTo(Object b) {
        CollegeStu stu=(CollegeStu)b;
        return (this.english-stu.english);
    }
}
public class T2 {
    public static void main(String[] args) {
        List<CollegeStu> list=new LinkedList<CollegeStu>();
        int score []={ 90, 88, 80};
        String name []={"张三","李四","王五"};
        for (int i=0;i<score.length;i++) {
            list.add(new CollegeStu(score[i],name[i]));
        }
        Iterator<CollegeStu> iter=list.iterator();
        TreeSet<CollegeStu> mytree=new TreeSet<CollegeStu>();
        while (iter.hasNext()) {
            CollegeStu stu=iter.next();
            mytree.add(stu);
        }
        Iterator<CollegeStu> te=mytree.iterator();
        while (te.hasNext()) {
            CollegeStu stu=te.next();
            System.out.println(""+stu.name+" "+stu.english);
        }
    }
}

• 运行结果截图：
  

(3)有10个U盘，有两个重要的属性：价格和容量，编写一个应用程序，使用TreeMap

• 代码：

import java.util.*;
class UDiscKey implements Comparable {
    double key=0;
    UDiscKey(double d) {
        key=d;
    }
    @Override
    public int compareTo(Object b) {
        UDiscKey disc=(UDiscKey)b;
        if((this.key-disc.key)==0) {
            return -1;
        }
        else {
            return (int) ((this.key - disc.key) * 1000);
        }
    }
}
class UDisc{
    int amount;
    double price;
    UDisc(int m,double e) {
        amount=m;
        price=e;
    }
}
public class T3 {
    public static void main(String args[ ]) {
        TreeMap<UDiscKey,UDisc>  treemap= new TreeMap<UDiscKey,UDisc>();
        int amount[]={8,16,32,64};
        double price[]={40,50,64,128};
        UDisc UDisc[]=new UDisc[4];
        for(int k=0;k<UDisc.length;k++) {
            UDisc[k]=new UDisc(amount[k],price[k]);
        }
        UDiscKey key[]=new UDiscKey[4] ;
        for(int k=0;k<key.length;k++) {
            key[k]=new UDiscKey(UDisc[k].amount);
        }
        for(int k=0;k<UDisc.length;k++) {
            treemap.put(key[k],UDisc[k]);
        }
        int number=treemap.size();
        Collection<UDisc> collection=treemap.values();
        Iterator<UDisc> iter=collection.iterator();
        while(iter.hasNext()) {
            UDisc disc=iter.next();
            System.out.println(""+disc.amount+"G "+disc.price+"元");
        }
        treemap.clear();
        for(int k=0;k<key.length;k++) {
            key[k]=new UDiscKey(UDisc[k].price);
        }
        for(int k=0;k<UDisc.length;k++) {
            treemap.put(key[k],UDisc[k]);
        }
        number=treemap.size();
        collection=treemap.values();
        iter=collection.iterator();
        while(iter.hasNext()) {
            UDisc disc=iter.next();
            System.out.println(""+disc.amount+"G "+disc.price+"元");
        }
    }
}

• 运行结果截图：
  

原文：https://www.cnblogs.com/wangyaojia/p/8998311.html