1 2 3 4

学号 2018-2019-20172309 《程序设计与数据结构（下）》第四周学习总结

第六章学习内容总结（列表）

教材学习内容总结

  • 6.1链表集合：
    • 列表集合是一种概念性表示法，使事物以线性列表的方式进行组织。
    • 链表集合没有内在的容量大小，他可以随需要而增大。
    • 链表结合分为：
  1. 有序列表：按照其元素内在的特性进行排序。//有序列表中的元素具有内在关联，这种关联定义了元素之间的顺序。
  2. 无序列表：其元素之间不具有内在的顺序，顺序为加入时的顺序。//无序列表的元素按照使用者所选择的方法排序。
  3. 索引列表： 元素用数字索引来引用。 //索引列表为他的元素维护一段连续的数字索引值。

  • 6.2 java集合API中的列表

    • list接口中的一些方法：

  • 6.3 使用无序列表：学习计划

    • 代码：
  1. course类
  2. ProgramOfStudy
  3. POSTester类
    • 运行结果：

  • 6.4索引列表使用实例：JosephUS问题

    • 代码：
    • 运行结果：

  • 6.5列表ADT

    • 代码：
  1. ListADt
  2. OrderedListADT
  3. UnOrderedListADT

课本学习遇到的问题

  • 问题一：课本P97页，串行化？
  • 解答：为了理解串行化，我们将从三个方面来理解它：是什么，怎么用，注意什么。

  1. （前序）Serializable（用于串行化）接口中没有任何的方法。当一个类声明要实现Serializable接口时，只是表明该类参加串行化协议，而不需要实现任何特殊的方法。

  2. 什么是串行化？
    对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力。叫作对象的持续性。对象通过写出描述自己状态的数值来记录自己 ，这个过程叫对象的串行化。

  3. 怎么串行化？

    1. 首先定义了一个类，实现了Serializable接口//课本中是course类实现了Serializable接口。
    2. 构造对象的输入／输出流//将对象的状态写入文件，再次打开再读取文件。
      总的来说就是为了记录一个东西的原来的状态，先把它记录下来并写到文件，最后读取就行了。

  4. 注意事项：

    1. 串行化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。
    2. 这样不是很安全，有可能有些private类型的数据被保留下来。
  • 问题二：
int targetIndex = list.indexOf(target);//此中的list.indexOf()方法是干嘛的？
        if (targetIndex != -1)
            list.set(targetIndex, newCourse);

  • 解答：此方法是javaAPI 中 java.util.List接口中的方法，作用是查到传入元素的索引，没有则返回-1.

  • 问题三：这个东西是个啥玩意儿？

public Iterator<Course> iterator()
    {
        return list.iterator();
    }
  • 解答：为了得到一个对象，用于集合内部的遍历。

敲代码中出现的错误

  • 问题一：在书上Josephus例子中，出现了小错误：

    数字出来的顺序应该是：3 6 2 7 5 1 4
  • 这个应该是每数三个数就删去一个，所以应该隔两个数，删一个。做法是：targetIndex = skip;、targetIndex = (targetIndex + skip) % list.size();改成targetIndex = skip-1;、targetIndex = (targetIndex + skip-1) % list.size();
  • 问题二：在写LinkedOrderedList类出现问题：

代码如图：

public void add(T element)
    {
        if (!(element instanceof Comparable))
            throw new NonComparableElementException("OrderedList");

        Comparable<T> comparableElement = (Comparable<T>)element;
        LinearNode<T> list=new LinearNode<T>(element);

         if(head==null) {//此处有错，请特别注意！
             list.setNext(head);
             head =tail= list;
         }

         else {
             LinearNode<T> current = null,current1 = head;
             while (current1.getNext() != null && comparableElement.compareTo(current1.getElement()) > 0)
             {
                 current = current1;
                 current1=current1.getNext();

             }
                 if(current1.getNext()==null)
                 {
                     tail.setNext(list);
                    tail=list;
                 }
                 else//此处有错，请特别注意！这是引起报错的地方
                 {
                     current.setNext(list);
                     list.setNext(current1);
                 }
         }

    }
}
  • 解决方法：正确代码
public void add(T element) {
        if (!(element instanceof Comparable))
            throw new NonComparableElementException("OrderedList");

        Comparable<T> comparableElement = (Comparable<T>)element;
        second_term.second_week.LinearNode<T> temp = new second_term.second_week.LinearNode<T>(element);
        if (count==0) {
            head = temp;
             tail = temp;
        }
        else {
            second_term.second_week.LinearNode<T> current0=null,current1=head;
            while(current1.getNext()!=null&&comparableElement.compareTo(current1.getElement())>0){//当插入第二个元素时，current1.getNext()==null
                current0=current1;
                current1= current1.getNext();
            }
            if (current1.getNext()==null){//此时需要与第一个元素比较，有可能比第一个元素小。
                if (comparableElement.compareTo(current1.getElement())>0){
                tail.setNext(temp);
                tail =temp;}
                else{
                    temp.setNext(head);
                    tail = head;
                    head = temp;
                }
            }
            else{//此处当已经插入 5 6 时，再插入2时需要分开判断，首先2与5比较，current0=null，current1 = head，
                if (comparableElement.compareTo(head.getElement())<0){
                    head =temp;
                    temp.setNext(current1);
                    tail = current1;
               }
                else{
                    current0.setNext(temp);//如果不分开判断，current0位null，没有next，所以报空指针异常
                    temp.setNext(current1);
                }
            }
        }
        count++;
    }

上周考试错题总结

第三、四章错题：

  • 错题一：
    理解情况：课本上的这张图大概能讲解：

  • 错题二：

  • 理解情况：多态的定义是允许不同的对象对同一消息作出不同的响应，所以只要向不同对象发出同一指令就OK了。

  • 错题三：

  • 理解情况：如果一个异常没有被捕获，他会沿着方法调用栈向下移，直到它被捕获，如果异常被捕获，就不会被传播。调用该方法的另一个方法就不会抛出异常。

  • 错题四：
    理解情况：数组声明时要求声明大小，当达到数组容量时，将调用方法进行扩容。

  • 错题五：

  • 理解情况：编程语言的底层实现就是数据结构。

第五章错题：

  • 全对，没错题。

代码托管

(上半年敲了7200行)

点评模板

队友博客中值得学习的地方：

- 队友很会排版，并没有像我的博客一样看起来头重脚轻的感觉。
- 队友的文字样式丰富，值得自己学习。

本周学习情况：

- [20172310]( http://www.cnblogs.com/Qiuxia2017/)
- 结对学习内容：
  1. 对实验一遇见的问题进行讨论。
   2. 教材第六章内容的共同学习。
    3. 第六章代码编写的讨论

学习进度条

代码行数（新增/累积） 博客量（新增/累积） 学习时间（新增/累积） 重要成长
目标 5000行 30篇 400小时
第一周 260/0 1/1 05/05
第二周 300/560 1/2 13/18
第三周 212/772 1/4 21/39
第四周 330/1112 2/7 21/60

参考资料

posted @ 2018-10-07 20:32  大大的梦  阅读(226)  评论(0)  编辑  收藏  举报