线性结构实验报告 20162305

实验一 ArrayList和LinkedList测试

要求：查看ArrayList和LinkedList的Java API帮助文档，参考http://www.cnblogs.com/rocedu/p/4837092.html 用Junit对ArrayList和LinkedList的方法进行测试，要尽量覆盖正常情况，异常情况，边界情况
关于ArrayList：List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。
每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
ArrayList中的一些方法
关于LinkedList：List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。
LinkedList中的一些方法
实验测试截图：

实验二：分别用Java的ArrayList和LinkedList实现有序线性表的合并

要求：aList，bList都是非递减线性表，合并后也是非递减
public static List<？ extends Comparable> mergeSortedList(List<？ extends Comparable> aList,
List<？ extends Comparable> bList)

测试mergeSortedList的正确性,要尽量覆盖正常情况，异常情况，边界情况，提交测试代码运行截图，包含学号信息

实验设计思路
本次实验设计是要用ArrayList实现有序线表的合并，我的想法是先定义三个线表，给前两个线表添加元素，然后再把两个表中的元素排好赋值给第三个线表。首先利用ArrayList中的add方法给两个线表添加元素，再利用while判断判断两个表中的元素大小,先将小的元素赋值进第三个线表，再继续比较下一个元素和上次比较较大的元素，再将较小的赋值给线表，循环遍历两个线表，直到结束停止，将第三个线表打印出来。
实验测试代码


import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.List;

public class mergeSortedList extends TestCase{
    public void testNormal() {

        List <Integer> cList = new ArrayList <>();
        List <Integer> aList = new ArrayList <>();
        List <Integer> bList = new ArrayList <>();

        aList.add(1);
        aList.add(3);
        aList.add(5);

        bList.add(2);
        bList.add(4);
        bList.add(6);



        int k = 0;
        int i = 0, j = 0;
        Integer bigger = 0, smaller = 0;
        while (i < aList.size() && j < bList.size()) {

            if (aList.get(i).compareTo(bList.get(j)) < 0) {
                smaller = aList.get(i);
                cList.add(smaller);
                i++;
            else
                bigger = bList.get(j);
                cList.add(bigger);
                j++;
            }


        }
        System.out.println(cList);
    }

}

实验测试截图

实验三：参考Java Foundation 3rd 第15.6节，用数组实现线性表List

要求：用JUnit或自己编写驱动类对自己实现的ArrayList进行测试，提交测试代码运行截图，要全屏，包含自己的学号信息
实验设计思路
设计一个ArrayList类，利用泛型，先定义一个空的数组list，再定义add、isEmpty、get方法。首先是add方法，这个方法的目的是给list中添加进元素，如果list为空的话，那么先定义list，包括它的容量（我的代码中设置的容量为10），再把t赋值给第一个元素。如果list不为空的话，则判断它有多少个元素，通过循环确定添加元素的位置，再添加元素，实现add方法。isEmpty方法是判断list是否为空，list为空返回true，不为空返回false。get方法是获取list中的一个元素。如果系数index小于0，则返回空，如果大于等于0，则返回该系数指向的元素。
MyArrayList实验代码


public class MyArrayList<T> {
    private T[] list = null;

    public boolean add(T t ){
        if(list == null) {
            list = (T[]) new Object[9];
            list[0] = t;
        }
        else
            for (int i = 0;i < this.list.length; i++){
                if (list[i] == null){
                    list[i] = t;
                    return true;
                }
        }
        return true;
    }
    public boolean isEmpty(){
        if (this.list == null)
            return true;
        else
            return false;
    }

    public T get(int index){
        if (index < 0)
            return null;
        else
            return this.list[index];
    }
}

实验测试截图

实验四：参考Java Foundation 3rd 第15.7节，用链表实现线性表List

要求：用JUnit或自己编写驱动类对自己实现的LinkedList进行测试，提交测试代码运行截图，要全屏，包含自己的学号信息
MyLinkedList实验代码
实验设计思路
LinkedList类中的一些方法的实现，在想法上同arraylist类似，不过在链表中需要考虑指针的问题。我们先定义一个空指针first，以下的方法实现都与first有关。removeFirst方法是删除第一个元素，我们先定义一个node等于first，再将node的下一个值赋给first，这样指针就指向了下一个，而第一个元素就被自动处理掉了。addFirst方法是将元素加在链表的开头，确定要添加的元素，再将first指向node的下一个元素，再把node赋值个first，使得first指向node。addNode方法是添加元素到链表中，先实例化一个Node对象，再定义两个Node变量，如果链表为空，则执行第一个addFirst方法，不为空，则利用两个变量遍历整个链表，利用next方法将元素添加到链表中。getNode方法是获取链表中的元素，根据系数确定返回出哪个元素，index为0则直接返回出第一个元素，不为零的话，利用循环到需要返回元素的位置，返回出所需要的元素。remove是删除一个元素，实现方法同addNode类似。


public class MyLinkedList<T>{
    private Node<T> first = null;

    public void removeFirst(){
        Node<T> node = first;
        first = node.next;
    }

    public void addFirst(T t){
        Node<T> node = new Node(t);
        node.next = first;
        first = node;
    }

    public void addNode(int index,T t){
        Node newN = new Node(t);
        Node curr = first;
        Node prev = first;
        if(index==0)addFirst(t);
        for(int i = 1;i<=index;i++){
            prev = curr;
            curr = curr.next;
        }
        prev.next = newN;
        newN.next = curr;
    }
    public T getNode(int index){
        Node currentNode = first;
        if(index==0)return first.data;
        for(int i = 1;i<=index;i++){
            currentNode = currentNode.next;
        }
        return (T) currentNode.data;
    }
    public void remove(int index){
        Node prev = first;
        Node curr = first;
        if(index==0)removeFirst();
        for(int i = 1;i<=index;i++){
            prev = curr;
            curr = curr.next;
        }
        prev.next = curr.next;

    }
}