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

最新推荐文章于 2024-07-12 16:35:20 发布

weixin_34306446

最新推荐文章于 2024-07-12 16:35:20 发布

阅读量111

点赞数

文章标签：数据结构与算法 markdown java

原文链接：http://www.cnblogs.com/dky-wzw/p/9745677.html

版权

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

教材学习内容总结

6.1链表集合：
- 列表集合是一种概念性表示法，使事物以线性列表的方式进行组织。
- 链表集合没有内在的容量大小，他可以随需要而增大。
- 链表结合分为：

有序列表：按照其元素内在的特性进行排序。//有序列表中的元素具有内在关联，这种关联定义了元素之间的顺序。
无序列表：其元素之间不具有内在的顺序，顺序为加入时的顺序。//无序列表的元素按照使用者所选择的方法排序。
索引列表：元素用数字索引来引用。 //索引列表为他的元素维护一段连续的数字索引值。

6.2 java集合API中的列表
- list接口中的一些方法：
6.3 使用无序列表：学习计划
- 代码：

6.4索引列表使用实例：JosephUS问题
- 代码：
- 运行结果：
6.5列表ADT
- 代码：

6.6用数组实现队列
- 数组实现队列：
  ArrayList
- 数组实现的队列实现有序队列
  OrderedArrayList
- 数组实现的队列实现无序数组
  UnorderedArrayList
6.7用链表实现对列
- 用队列实现对列
  LinkedList

课本学习遇到的问题

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

（前序）Serializable（用于串行化）接口中没有任何的方法。当一个类声明要实现Serializable接口时，只是表明该类参加串行化协议，而不需要实现任何特殊的方法。
什么是串行化？
对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力。叫作对象的持续性。对象通过写出描述自己状态的数值来记录自己，这个过程叫对象的串行化。
怎么串行化？
1. 首先定义了一个类，实现了Serializable接口//课本中是course类实现了Serializable接口。
2. 构造对象的输入／输出流//将对象的状态写入文件，再次打开再读取文件。
  总的来说就是为了记录一个东西的原来的状态，先把它记录下来并写到文件，最后读取就行了。
注意事项：
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

参考资料

转载于:https://www.cnblogs.com/dky-wzw/p/9745677.html

weixin_34306446

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学号 2018-2019-20172309 《程序设计与数据结构（下）》第四周学习总结

第六章学习内容总结（列表）教材学习内容总结6.1链表集合：列表集合是一种概念性表示法，使事物以线性列表的方式进行组织。链表集合没有内在的容量大小，他可以随需要而增大。链表结合分为：有序列表：按照其元素内在的特性进行排序。//有序列表中的元素具有内在关联，这种关联定义了元素之间的顺序。无序列表：其元素之间不具有内在的顺序，顺序为加入时的顺序。//无序列表的元素按照使用者所选择...
复制链接

扫一扫