XJTUSE 数据结构与算法第二次作业——任务1和任务2

任务1

1. 题目

在本次实验中，主要完成的任务是：

1、为指定的 List ADT（该 ADT 的具体要求请参见文件 List.java）实现三种数据结构：①使用顺序数组做为存储表示； ②使用单向链表做为存储表示； ③使用双向链表做为存储表示。不论哪种存储表示下实现的数据结构，实验中需要处理的数据类型都是 Character 类型。

2、用给定的输入数据文件验证所实现的数据结构是否正确。

3、使用表格列举每种数据结构下所实现的所有方法的时间复杂度。

为了方便进行测试验证，对 List 的各种操作指定了相应的命令符号，具体的符号含义如下：

实验完成之后，必须通过实验中提供的测试用例。借助测试用例的运行结果，用来检查所撰写的代码功能是否正确。

测试用例中的每一行的内容都类似于上表中的每一行“命令行内容”列中所指示的内容。要求每执行一行，就调用 List 接口中的 showStructure 行为，用以验证该命令行的执行是否正确。

每行“命令行内容”都不是独立的，是针对同一个 List 类型的对象实例运行的结果。实验包里包括了个文件，一个是“list_testcase.txt”，其内包含了测试用例；另一个是“list_result.txt”，其内包含了对应测试用例的运行结果。

1. 数据设计

实验要求三个数据结构分别是数组、单向链表、双向链表，三者都实现了List<T>, Iterable<T>。

数组Array包括private T[] storage表示储存的数组；private int capacity表示容量；private int count表示元素数量；private int curr表示当前元素的位置。

Capacity等于题目要求512，curr最开始指向-1，为了方便遍历实现了抽象方法public Iterator<T> iterator()。

1. public class Array<T> implements List<T>, Iterable<T> {
3.     private T[] storage;//储存的数组
4.     private int capacity;//容量
5.     private int count;//元素数量
6.     private int curr;//当前元素的位置
8.     //不带初始容量的构造方法。默认容量为512
9.     public Array() {
10.         this.capacity = 512;
11.         this.curr = -1;
12.         this.storage = (T[]) new Object[512];
13.         this.count = 0;
14.     }
16.     @Override
17.     public Iterator<T> iterator() {
18.         curr = 0;
19.         return new Iterator<T>() {
20.             @Override
21.             public boolean hasNext() {
22.                 return curr < count;
23.             }
25.             @Override
26.             public T next() {
27.                 T value = storage[curr];
28.                 curr++;
29.                 return value;
30.             }
31.         };
32.     }
33. }

单向链表SingleLinkedListSentinel<T>包括内部类Node<T>，Node<T>有T value和Node<T> next；还有两个哨兵节点private Node<T> head和private Node<T> tail以及指针private Node<T> p。

单向链表节点head指向节点tail，指针p指向head，为了方便遍历实现了抽象方法public Iterator<T> iterator()。

1. public class SingleLinkedListSentinel<T> implements List<T>, Iterable<T> {
3.     private static class Node<T> {
4.         T value;
5.         Node<T> next;
7.         public Node(T value, Node<T> next) {
8.             this.value = value;
9.             this.next = next;
10.         }
11.     }
13.     //两个哨兵节点
14.     private Node<T> head;
15.     private Node<T> tail;
16.     private Node<T> p;//指针
18.     public SingleLinkedListSentinel() {
19.         head = new Node<T>(null, null);
20.         tail = new Node<T>(null, null);
21.         head.next = tail;
22.         p = head;
23.     }
25.     @Override
26.     public Iterator<T> iterator() {
27.         return new Iterator<T>() {
28.             Node<T> p = head.next;
30.             @Override
31.             public boolean hasNext() {
32.                 return p != tail;
33.             }
35.             @Override
36.             public T next() {
37.                 T value = p.value;
38.                 p = p.next;
39.                 return value;
40.             }
41.         };
42.     }
43. }

双向链表DoubleLinkedListSentinel<T>包括内部类Node<T>，Node<T>有T value、Node<T> next和Node<T> prev；还有两个哨兵节点private Node<T> head和private Node<T> tail以及指针private Node<T> p。

双向链表节点head的next指向节点tail，tail的prev指向head，指针p指向head，为了方便遍历实现了抽象方法public Iterator<T> iterator()。

1. public class DoubleLinkedListSentinel<T> implements List<T>, Iterable<T> {
3.     private static class Node<T> {
4.         T value;
5.         Node<T> next;
6.         Node<T> prev;
8.         public Node(T value, Node<T> next, Node<T> prev) {
9.             this.value = value;
10.             this.next = next;
11.             this.prev = prev;
12.         }
13.     }
15.     //两个哨兵节点
16.     private Node<T> head;
17.     private Node<T> tail;
18.     private Node<T> p;//指针
20.     public DoubleLinkedListSentinel() {
21.         head = new Node<T>(null, null, null);
22.         tail = new Node<T>(null, null, null);
23.         head.next = tail;
24.         tail.prev = head;
25.         p = head;
26.     }
27.     @Override
28.     public Iterator<T> iterator() {
29.         return new Iterator<T>() {
30.             Node<T> p = head.next;
32.             @Override
33.             public boolean hasNext() {
34.                 return p != tail;
35.             }
37.             @Override
38.             public T next() {
39.                 T value = p.value;
40.                 p = p.next;
41.                 return value;
42.             }
43.         };
44.     }
45. }

1. 算法设计

当实现了三种数据结构后，剩下比较难办的就是怎么用StreamTokenizer实现命令行。

注意到每一行都会生成一个{capacity = 16, length = 13, cursor = 1}，也就是每一行调用一次showStructure(writer)。我们可以把根据行读入，然后当有下一行时做相应的操作。

1.         String line;
2.         while ((line = br.readLine()) != null) {
3.             executeCommand(array, line);
4.             array.showStructure(writer); 
5.             writer.flush(); // 刷新PrintWriter的缓冲区
6.         }
8.         writer.close(); // 在循环结束后关闭PrintWriter对象

为了方便起见，我们把读取标记并进行相对应的动作用方法抽离出来：

1.     private static void executeCommand(DynamicArray<Object> array, String line) throws ListException, IOException {
2.         StreamTokenizer st = new StreamTokenizer(new StringReader(line));
3.         int token = st.nextToken();
4.         while (token != StreamTokenizer.TT_EOF) {
5.             char command = (char) st.ttype;
6.             switch (command) {
7.                 case '+' -> {
8.                     st.nextToken();
9.                     array.insert(st.sval);
10.                 }
11.                 case '-' -> array.remove();
12.                 case '=' -> {
13.                     st.nextToken();
14.                     array.replace(st.sval);
15.                 }
16.                 case '#' -> array.gotoBeginning();
17.                 case '*' -> array.gotoEnd();
18.                 case '>' -> array.gotoNext();
19.                 case '<' -> array.gotoPrev();
20.                 case '~' -> array.clear();
21.             }
22.             token = st.nextToken();
23.         }
24.     }

当碰见+和=时，读取+或者=后面的符号并调用相对于的方法。读取到其他符号时，直接调用相对应的方法。

1. 主干代码分析

1. Array

1.    /**
2.      * 在当前位置插入一个元素
3.      * 从curr开始的元素全部向后移动一位
4.      * curr指向被插入的元素
5.      */
6.     @Override
7.     public void insert(T newElement) throws ListException {
8.         //列表满了
9.         if (isFull()) {
10.             return;
11.         }
12.         if (curr < -1 || curr > capacity) {
13.             throw new ListException("插入位置不合适");
14.         }
15.         if(isEmpty()){
16.             curr = -1;
17.         }
18.         for (int i = count - 1; i > curr; i--) {
19.             storage[i + 1] = storage[i];
20.         }
21.         curr++;
22.         storage[curr] = newElement;
23.         count++;
24.     }

数组的insert实现起来很简单，需要注意的是各种特殊情况的处理。数组满了直接return；插入位置不合法则报错；数组为空时，把curr置为-1，因为下面要让curr++；随后将数组指针后面的所有元素依次向后移一位，再插入相应的数据即可。

如果插入位置合适，即curr在有效范围内（0到count-1之间），则需要将从curr开始的元素全部向后移动一位。这个操作的时间复杂度为O(n)，其中n是从curr到count-1的元素个数。在移动元素后，将新元素插入到curr位置，并更新curr和count。这个操作的时间复杂度为O(1)。

综上所述，insert的时间复杂度是O(n)。

1.     /**
2.      * 从列表中移除游标标记的元素
3.      * 如果结果列表不为空，则将光标移动到被删除元素后面的元素
4.      * 如果被删除的元素位于列表末尾，则将光标移动到列表开头的元素
5.      */
6.     @Override
7.     public void remove() {
8.         //如果列表不为空就把后面的元素前移就行，如果已经空了就不用管了
9.         if (!isEmpty()) {
10.             for (int i = curr + 1; i < count; i++) {
11.                 storage[i - 1] = storage[i];
12.             }
13.             count--;
14.             if (count == curr) {
15.                 curr = 0;
16.             }
17.         }
18.     }

首先，检查列表是否为空。如果列表为空，即没有元素可移除，直接返回。这个操作的时间复杂度为 O(1)。如果列表不为空，需要将光标之后的元素向前移动一位。这个操作的时间复杂度取决于需要移动的元素个数，即从 curr + 1 到 count - 1 的元素个数，记为 n。在移动元素后，将列表中的元素个数减 1，并根据情况更新光标位置。这个操作的时间复杂度为 O(1)。

综上所述，remove 方法的时间复杂度为 O(n)。

1.     /**
2.      * 先决条件：List不为空，newElement也不为空。
3.      * 后置条件：用newElement替换游标标记的元素。游标保持在newElement处
4.      */
5.     @Override
6.     public void replace(T newElement) {
7.         if(isEmpty()){
8.             return;
9.         }
10.         storage[curr] = newElement;
11.     }

首先，检查列表是否为空。如果列表为空，即没有元素可替换，直接返回。这个操作的时间复杂度为 O(1)。如果列表不为空，则将游标标记的元素替换为新元素 newElement。这个操作的时间复杂度为 O(1)，因为它只涉及一次元素的替换。

综上所述， replace 方法的时间复杂度为 O(1)。

1.     //删除列表中所有元素
2.     @Override
3.     public void clear() {
4.         Arrays.fill(storage, 0, count, null);  // 将数组中的元素设为null
5.         count = curr = 0;//元素清空
6.     }

首先，通过调用 Arrays.fill() 方法将数组 storage 中从索引 0 到索引 count-1 的元素设为 null。这个操作的时间复杂度为 O(n)，其中 n 是列表中的元素个数。接着，将列表中的元素个数 count 和游标位置 curr 都设为 0。这个操作的时间复杂度为 O(1)。

综上所述，整个 clear 方法的时间复杂度为 O(n)。

1.     @Override
2.     public boolean isEmpty() {
3.         return count == 0;
4.     }
6.     @Override
7.     public boolean isFull() {
8.         return count == capacity;
9.     }

isEmpty 和 isFull 方法的时间复杂度均为 O(1)。

1.     //如果列表不为空，则将光标移动到列表的开头并返回true。否则,返回false。
2.     @Override
3.     public boolean gotoBeginning() {
4.         if (!isEmpty()) {
5.             curr = 0;
6.             return true;
7.         } else {
8.             return false;
9.         }
10.     }
12.     @Override
13.     public boolean gotoEnd() {
14.         if (!isEmpty()) {
15.             curr = count - 1;
16.             return true;
17.         } else {
18.             return false;
19.         }
20.     }
22.     @Override
23.     public boolean gotoNext() {
24.         if (isEmpty() || curr == count - 1) {
25.             return false;
26.         }
27.         curr++;
28.         return true;
29.     }
31.     @Override
32.     public boolean gotoPrev() {
33.         if (isEmpty() || curr == 0) {
34.             return false;
35.         }
36.         curr--;
37.         return true;
38.     }

对于数组来说，这四个goto方法都是常数级的，这四个方法的时间复杂度均为 O(1)。

1.     /**
2.      * 前提条件: List不为空。
3.      * 返回游标所标记元素的副本。
4.      */
5.     @Override
6.     public T getCursor() {
7.         return storage[curr];
8.     }

GetCursor的时间复杂度也是 O(1)。

1.     /**
2.      * 输出列表中的元素和游标的值。
3.      * 如果列表为空，则输出“empty list”。
4.      * 注意，此操作仅用于测试/调试目的。
5.      */
6.     @Override
7.     public void showStructure(PrintWriter pw) {
8.         int current = curr;
9.         if (isEmpty()) {
10.             pw.print("Empty list");
11.             pw.print("{capacity = ");
12.             pw.print(capacity);
13.             pw.print(", length = ");
14.             pw.print(count);
15.             pw.print(", cursor = ");
16.             pw.print(-1);
17.             pw.println("}");
18.         } else {
19.             gotoBeginning();
20.             for (int i = 0; i < count; i++) {
21.                 pw.print(storage[i] + " ");
22.             }
23.             curr = current;
24.             pw.print("{capacity = ");
25.             pw.print(capacity);
26.             pw.print(", length = ");
27.             pw.print(count);
28.             pw.print(", cursor = ");
29.             pw.print(curr);
30.             pw.println("}");
31.         }
32.     }

首先，检查列表是否为空。这个操作的时间复杂度为 O(1)。

如果列表为空，则输出固定的字符串和列表的一些属性值，这是一个常数时间操作。

如果列表不为空，则将光标 curr 移动到列表的开头。这个操作的时间复杂度为 O(1)。接下来，使用一个循环来遍历列表中的元素，并输出它们。由于遍历的次数取决于列表中的元素个数 n，因此这个操作的时间复杂度为 O(n)。最后，将光标 curr 恢复到原来的位置，输出列表的其他属性值，这都是常数时间操作。

综上所述，当array不为空时，整个 showStructure 方法的时间复杂度为 O(n)，当array为空时，方法时间复杂度是O(1)。

1.     /**
2.      * 前提条件:列表至少包含n + 1个元素。
3.      * 从列表中删除游标标记的元素
4.      * 并将其作为列表中的第n个元素重新插入
5.      * 其中的元素从0开始从头到尾编号
6.      * 将光标移动到被移动的元素。
7.      */
8.     @Override
9.     public void moveToNth(int n) throws ListException {
10.         if (count < n + 1) {
11.             System.out.println("输入的n过大");
12.             return;
13.         }
14.         T removed = getCursor();
15.         remove();
16.         gotoN(n);
17.         insert(removed);
18.     }

首先，检查列表中的元素个数是否至少为 n + 1。如果不满足该条件，输出错误信息并返回。这个操作的时间复杂度为 O(1)。

如果满足条件，首先获取当前游标标记的元素 removed，这是一个常数时间操作。调用 remove 方法删除当前元素，这个操作的时间复杂度为 O(n)，其中 n 是当前游标之后的元素个数。调用 gotoN 方法将光标移动到第 n 个位置，这个操作的时间复杂度为 O(n)。

调用 insert 方法将之前删除的元素 removed 插入到列表中，这个操作的时间复杂度为 O(n)。

综上所述，整个 moveToNth 方法的时间复杂度为 O(n)。

1.     /**
2.      * 前提条件: List不为空。
3.      * 在列表中搜索searchElement。
4.      * 从游标标记的元素开始搜索。在列表中移动光标，直到找到searchElement(返回true)
5.      * 或到达列表末尾而没有找到searchElement(返回false)。
6.      * 将游标留在搜索期间访问的最后一个元素处。
7.      */
8.     @Override
9.     public boolean find(T searchElement) {
10.         while (curr <= count) {
11.             if(storage[curr] == searchElement){
12.                 return true;
13.             }
14.             curr++;
15.         }
16.         return false;
17.     }

首先，检查列表是否为空。如果列表为空，直接返回 false。这个操作的时间复杂度为 O(1)。

如果列表不为空，进入循环。循环的次数取决于n，即列表中的元素个数。在每次循环中，进行元素的比较操作 storage[curr] == searchElement，这是一个常数时间操作。如果找到了匹配的元素，返回 true。如果循环完毕仍未找到匹配的元素，返回 false。

综上所述，整个 find 方法的时间复杂度为 O(n)。

1. SingleLinkedListSentinel

1.     /**
2.      * 前提条件:List不满且newElement不为空。
3.      * 后置条件:
4.      * 将newElement插入到游标后面的列表中。如果列表为空，则插入newElement作为列表中的第一个(也是唯一一个)元素。
5.      * 在两种情况下(空或不空)，将光标移动到newElement。
6.      * 如果列表中没有足够的空间，抛出一个ListException异常。
7.      */
8.     @Override
9.     public void insert(T newElement) throws ListException {
10.         Node<T> added = new Node<>(newElement, p.next);
11.         p.next = added;
12.         p = added;
13.     }
15.     /**
16.      * 先决条件:
17.      * 列表不是空的。
18.      * 后置条件:
19.      * 从列表中移除游标标记的元素。如果结果列表不为空，
20.      * 然后将光标移动到被删除元素后面的元素。如果删除的元素
21.      * 位于列表末尾，然后将光标移动到列表开头的元素。
22.      */
23.     @Override
24.     public void remove() {
25.         if (!isEmpty()) {
26.             gotoPrev();
27.             p.next = p.next.next;
28.             gotoNext();
29.             if (p.next == tail) {
30.                 gotoBeginning();
31.             }
32.         }
33.     }
35.     /**
36.      * 先决条件:
37.      * List不为空，newElement也不为空。
38.      * 后置条件:
39.      * 用newElement替换游标标记的元素。游标保持在newElement处。
40.      */
41.     @Override
42.     public void replace(T newElement) {
43.         p.value = newElement;
44.     }
46.     /**
47.      * 先决条件:
48.      * 没有
49.      * 后置条件:
50.      * 删除列表中的所有元素。
51.      */
52.     @Override
53.     public void clear() {
54.         head.next = tail;
55.         p = head;
56.     }

insert(T newElement): 插入一个新元素到游标后面的列表中。时间复杂度为 O(1)，因为只需要修改几个指针的指向。

remove(): 从列表中移除游标标记的元素。时间复杂度为 O(1)，因为只需要修改几个指针的指向。

replace(T newElement): 用新元素替换游标标记的元素。时间复杂度为 O(1)，因为只需要修改游标所在节点的值。

clear(): 删除列表中的所有元素。时间复杂度为 O(1)，因为只需要修改几个指针的指向。

1.     @Override
2.     public boolean isEmpty() {
3.         return head.next == tail;
4.     }
6.     @Override
7.     public boolean isFull() {
8.         return false;
9.     }
11.     @Override
12.     public boolean gotoBeginning() {
13.         if (!isEmpty()) {
14.             p = head.next;
15.             return true;
16.         } else {
17.             return false;
18.         }
19.     }
21.     @Override
22.     public boolean gotoEnd() {
23.         if (!isEmpty()) {
24.             Node<T> pi = head.next;
25.             while (pi.next != tail) {
26.                 pi = pi.next;
27.             }
28.             p = pi;
29.             return true;
30.         } else {
31.             return false;
32.         }
33.     }
35.     @Override
36.     public boolean gotoNext() {
37.         if (p.next != tail) {
38.             p = p.next;
39.             return true;
40.         } else {
41.             return false;
42.         }
43.     }
45.     @Override
46.     public boolean gotoPrev() {
47.         if (p == head || p == null) {
48.             return false; // 已经是第一个节点或者p为空
49.         } else {
50.             Node<T> pi = head;
51.             while (pi.next != p) {
52.                 pi = pi.next;
53.                 if (pi == null) { // 如果已经到达链表尾部，说明p不是链表中的节点
54.                     return false;
55.                 }
56.             }
57.             p = pi; // 现在pi就是p的前一个节点
58.             return true;
59.         }
60.     }

isEmpty(): 检查列表是否为空。时间复杂度为 O(1)，因为只需要比较头结点的下一个节点是否为尾节点。

isFull(): 检查列表是否已满。由于该实现是基于链表的，没有固定大小，因此永远不会满。时间复杂度为 O(1)。

gotoBeginning(): 将游标移动到列表开头的元素。时间复杂度为 O(1)，因为只需要将游标指向头结点的下一个节点。

gotoEnd(): 将游标移动到列表末尾的元素。时间复杂度为 O(n)，其中 n 是列表的长度，因为需要遍历整个链表。

gotoNext(): 将游标移动到下一个元素。时间复杂度为 O(1)，因为只需要将游标指向其下一个节点。

gotoPrev(): 将游标移动到前一个元素。时间复杂度为 O(n)，其中 n 是列表的长度，因为需要从头开始遍历链表，直到找到游标所在节点的前一个节点。因为这是单向链表才会如此复杂。

1.     /**
2.      * 先决条件:
3.      * 没有
4.      * 后置条件:
5.      * 输出列表中的元素和光标的值。如果列表为空，则输出“empty list”。
6.      * 注意，此操作仅用于测试/调试目的。
7.      */
8.     @Override
9.     public void showStructure(PrintWriter pw) {
10.         if (isEmpty()) {
11.             pw.print("Empty list ");
12.             pw.println("{capacity = 0, length = 0, cursor = -1}");
13.         } else {
14.             Node<T> pi = p;
15.             int current = getN(p);
16.             gotoEnd();
17.             int capacity = getN(p) + 1;
19.             gotoBeginning();
20.             while (p != tail) {
21.                 pw.print(p.value + " ");
22.                 p = p.next;
23.             }
24.             pw.print("{capacity = ");
25.             pw.print(capacity);
26.             pw.print(", length = ");
27.             pw.print(capacity);
28.             pw.print(", cursor = ");
29.             pw.print(current);
30.             pw.println("}");
31.             p = pi;
32.         }
33.     }

首先，检查列表是否为空。这个操作的时间复杂度为 O(1)。

如果列表为空，则输出固定的字符串和列表的一些属性值，这是一个常数时间操作。

如果列表不为空，则调用getN(p)得到p在链表的位置，这个操作的时间复杂度为 O(n)；然后将游标移动到列表末尾的元素，时间复杂度为 O(n)，再调用getN(p)得到p在链表的位置，加1后就是链表的长度；则将光标 curr 移动到列表的开头，这个操作的时间复杂度为 O(1)。接下来，使用一个循环来遍历列表中的元素，并输出它们。由于遍历的次数取决于列表中的元素个数 n，因此这个操作的时间复杂度为 O(n)。最后，将光标 curr 恢复到原来的位置，输出列表的其他属性值，这都是常数时间操作。

综上所述，当array不为空时，整个 showStructure 方法的时间复杂度为 O(n)，当array为空时，方法时间复杂度是O(1)。

1.     /**
2.      * 先决条件:
3.      * 列表至少包含n + 1个元素。
4.      * 后置条件:
5.      * 从列表中删除被游标标记的元素，并将其作为列表中的第n个元素重新插入，其中的元素从0开始从头到尾编号。将光标移动到被移动的元素。
6.      */
7.     @Override
8.     public void moveToNth(int n) {
9.         Node<T> pi = p;
10.         remove();
11.         gotoBeginning();
12.         for (int i = 0; i < n; i++) {
13.             p = p.next;
14.         }
15.         pi.next = p.next;
16.         p.next = pi;
17.         p = p.next;
18.     }

首先将游标所在节点保存到临时变量 pi 中。时间复杂度为 O(1)。调用remove()和gotoBeginning()，时间复杂度为 O(1)。接着将游标移动到第 n 个元素，间复杂度为 O(n)。接下来移动指针，时间复杂度为 O(1)。

综上所述，moveToNth(int n) 方法的时间复杂度为 O(n)。

1.     /**
2.      * 先决条件:
3.      * 列表不是空的。
4.      * 后置条件:
5.      * 在列表中搜索searchElement。从游标标记的元素开始搜索。在列表中移动光标，直到找到searchElement(返回true)或到达列表末尾而没有找到searchElement(返回false)。将游标留在搜索期间访问的最后一个元素处。
6.      */
7.     @Override
8.     public boolean find(T searchElement) {
9.         if (isEmpty()) {
10.             return false;
11.         } else {
12.             while (p != tail) { // 当未到达链表末尾时，继续搜索
13.                 if (p.value.equals(searchElement)) { // 如果找到元素，返回true
14.                     return true;
15.                 }
16.                 p = p.next; // 移动到下一个节点
17.             }
18.             return false; // 如果到达链表末尾仍未找到元素，返回false
19.         }
20.     }

检查列表是否为空，时间复杂度为 O(1)。当游标未到达链表末尾时，继续搜索，时间复杂度取决于列表中需要遍历的元素数量。 检查当前节点的值是否等于搜索元素，时间复杂度为 O(1)。将游标移动到下一个节点，时间复杂度为 O(1)。

综上所述，find方法的时间复杂度取决于列表中需要遍历的元素数量。如果搜索元素在列表中，则最坏情况下需要遍历整个链表，因此时间复杂度为 O(n)，其中 n 是列表的长度。如果搜索元素不在列表中，时间复杂度为 O(n)，其中 n 是列表的长度，因为需要遍历整个链表。

1. DoubleLinkedListSentinel

1.     /**
2.      * 前提条件:List不满且newElement不为空。
3.      * 后置条件:
4.      * 将newElement插入到游标后面的列表中。如果列表为空，则插入newElement作为列表中的第一个(也是唯一一个)元素。
5.      * 在两种情况下(空或不空)，将光标移动到newElement。
6.      * 如果列表中没有足够的空间，抛出一个ListException异常。
7.      */
8.     @Override
9.     public void insert(T newElement) throws ListException {
10.         Node<T> next = p.next;
11.         Node<T> added = new Node<>(newElement, p.next, p);
12.         next.prev = added;
13.         p.next = added;
14.         p = added;
15.     }
17.     /**
18.      * 先决条件:
19.      * 列表不是空的。
20.      * 后置条件:
21.      * 从列表中移除游标标记的元素。如果结果列表不为空，
22.      * 然后将光标移动到被删除元素后面的元素。如果删除的元素
23.      * 位于列表末尾，然后将光标移动到列表开头的元素。
24.      */
25.     @Override
26.     public void remove() {
27.         if (!isEmpty()) {
28.             Node<T> prev = p.prev;
29.             Node<T> next = p.next;
30.             prev.next = next;
31.             next.prev = prev;
32.             p = next;
33.             if(p == tail && !isEmpty()){
34.                 gotoBeginning();
35.             } else if (p == tail && isEmpty()) {
36.                 p = head;
37.             }
38.         }
39.     }
41.     /**
42.      * 先决条件:
43.      * List不为空，newElement也不为空。
44.      * 后置条件:
45.      * 用newElement替换游标标记的元素。游标保持在newElement处。
46.      */
47.     @Override
48.     public void replace(T newElement) {
49.         if (!isEmpty() && newElement != null) {
50.             p.value = newElement;
51.         }
52.     }
54.     /**
55.      * 先决条件:
56.      * 没有
57.      * 后置条件:
58.      * 删除列表中的所有元素。
59.      */
60.     @Override
61.     public void clear() {
62.         head.next = tail;
63.         tail.prev = head;
64.         p = head;
65.     }
67.     @Override
68.     public boolean isEmpty() {
69.         return head.next == tail;
70.     }
72.     @Override
73.     public boolean isFull() {
74.         return false;
75.     }
77.     @Override
78.     public boolean gotoBeginning() {
79.         if (!isEmpty()) {
80.             p = head.next;
81.             return true;
82.         } else {
83.             return false;
84.         }
85.     }
87.     @Override
88.     public boolean gotoEnd() {
89.         if (!isEmpty()) {
90.             p = tail.prev;
91.             return true;
92.         } else {
93.             return false;
94.         }
95.     }
97.     @Override
98.     public boolean gotoNext() {
99.         if(isEmpty()){
100.             return false;
101.         }
102.         if (p.next != tail) {
103.             p = p.next;
104.             return true;
105.         } else {
106.             return false;
107.         }
108.     }
110.     @Override
111.     public boolean gotoPrev() {
112.         if(isEmpty()){
113.             return false;
114.         }
115.         if (p.prev != head) {
116.             p = p.prev;
117.             return true;
118.         } else {
119.             return false;
120.         }
121.     }
123.     /**
124.      * 先决条件:
125.      * 列表不是空的。
126.      * 后置条件:
127.      * 返回由游标标记的元素的副本。
128.      */
129.     @Override
130.     public T getCursor() {
131.         if (!isEmpty()) {
132.             return p.value;
133.         }
134.         return null;
135.     }
137.     /**
138.      * 先决条件:
139.      * 没有
140.      * 后置条件:
141.      * 输出列表中的元素和光标的值。如果列表为空，则输出“empty list”。
142.      * 注意，此操作仅用于测试/调试目的。
143.      */
144.     @Override
145.     public void showStructure(PrintWriter pw) {
146.         if (isEmpty()) {
147.             pw.print("Empty list ");
148.             pw.println("{capacity = 0, length = 0, cursor = -1}");
149.         } else {
150.             Node<T> pi = p;
151.             int current = getN(p);
152.             gotoEnd();
153.             int capacity = getN(p) + 1;
154.             gotoBeginning();
155.             while (p != tail) {
156.                 pw.print(p.value + " ");
157.                 p = p.next;
158.             }
159.             pw.print("{capacity = ");
160.             pw.print(capacity);
161.             pw.print(", length = ");
162.             pw.print(capacity);
163.             pw.print(", cursor = ");
164.             pw.print(current);
165.             pw.println("}");
167.             p = pi;
168.         }
169.     }
171.     private int getN(Node<T> p) {
172.         if (head == null) { // 链表为空
173.             return -1;
174.         }
175.         Node<T> pi = head;
176.         int i = 0;
177.         while (pi != null && p != pi.next) { // 检查pi是否为null
178.             pi = pi.next;
179.             i++;
180.         }
181.         // 如果pi为null，说明p不在链表中或者链表已经遍历完
182.         if (pi == null) {
183.             return -1;
184.         }
185.         return i;
186.     }
188.     /**
189.      * 先决条件:
190.      * 列表至少包含n + 1个元素。
191.      * 后置条件:
192.      * 从列表中删除被游标标记的元素，并将其作为列表中的第n个元素重新插入，其中的元素从0开始从头到尾编号。将光标移动到被移动的元素。
193.      */
194.     @Override
195.     public void moveToNth(int n) {
196.         Node<T> pi = p;
197.         remove();
198.         gotoBeginning();
199.         for (int i = 0; i < n; i++) {
200.             p = p.next;
201.         }
202.         Node<T> pj = p.next;
203.         pi.next = p.next;
204.         p.next = pi;
205.         pj.prev = pi;
206.         pi.prev = p;
207.         p = p.next;
208.     }
210.     /**
211.      * 先决条件:
212.      * 列表不是空的。
213.      * 后置条件:
214.      * 在列表中搜索searchElement。从游标标记的元素开始搜索。在列表中移动光标，直到找到searchElement(返回true)或到达列表末尾而没有找到searchElement(返回false)。将游标留在搜索期间访问的最后一个元素处。
215.      */
216.     @Override
217.     public boolean find(T searchElement) {
218.         if (isEmpty()) {
219.             return false;
220.         } else {
221.             while (p != tail) { // 当未到达链表末尾时，继续搜索
222.                 if (p.value.equals(searchElement)) { // 如果找到元素，返回true
223.                     return true;
224.                 }
225.                 p = p.next; // 移动到下一个节点
226.             }
227.             return false; // 如果到达链表末尾仍未找到元素，返回false
228.         }
229.     }

双向链表和单向链表大部分都方法实现都很类似，由于头尾节点和双向指针的存在，gotoEnd和gotoPrev方法可以在时间复杂度为O(1)的情况下实现。showStructure、moveToNth、find方法虽然仍然是O(n)，但是相对来说比单向链表快一些。

1. 运行结果展示

首先测试Array：

我们可以直接把输出打印在控制台，结果如下：

用人眼无法看出来我们打印在控制台的和答案是否相同，所以我们将PrintWriter打印到一个文件output.txt中，再比较两个文件是否相同。为此写了一个类TextFileComparator。

1. package Homework0102;
2. import java.io.BufferedReader;
3. import java.io.FileReader;
4. import java.io.IOException;
6. public class TextFileComparator {
7.     public static boolean compareFiles(String filePath1, String filePath2) {
8.         try (BufferedReader reader1 = new BufferedReader(new FileReader(filePath1));
9.              BufferedReader reader2 = new BufferedReader(new FileReader(filePath2))) {
10.             String line1, line2;
11.             while ((line1 = reader1.readLine()) != null) {
12.                 line2 = reader2.readLine();
13.                 if (!line1.equals(line2)) {
14.                     return false;
15.                 }
16.             }
17.             // Check if file2 has additional lines
18.             return reader2.readLine() == null;
19.         } catch (IOException e) {
20.             e.printStackTrace();
21.             return false;
22.         }
23.     }
25.     public static void main(String[] args) {
26.         String file1 = "D:\\develop\\projects\\dataStructure\\homework02\\src\\Homework0102\\list_result.txt";
27.         String file2 = "D:\\develop\\projects\\dataStructure\\homework02\\src\\Homework0102\\output.txt";
29.         boolean areEqual = compareFiles(file1, file2);
30.         if (areEqual) {
31.             System.out.println("两个文件的内容相同");
32.         } else {
33.             System.out.println("两个文件的内容不同");
34.         }
35.     }
36. }

结果如下：

测试SingleLinkedListSentinel和DoubleLinkedListSentinel：

链表的capacity总会与count相同，但是我们缺少相对应的文件，所以不能再用上述的方式看是否正确。我们只能用肉眼看。结果分别如下：

SingleLinkedListSentinel的测试用例额对应的测试结果（部分）

DoubleLinkedListSentinel的测试用例额对应的测试结果（部分）

1. 时间复杂度展示

	Array	SingleLinkedListSentinel	DoubleLinkedListSentinel
insert	O(n)	O(1)	O(1)
remove	O(n)	O(1)	O(1)
replace	O(1)	O(1)	O(1)
clear	O(n)	O(1)	O(1)
isEmpty	O(1)	O(1)	O(1)
isFull	O(1)	O(1)	O(1)
gotoBeginning	O(1)	O(1)	O(1)
gotoEnd	O(1)	O(n)	O(1)
gotoNext	O(1)	O(1)	O(1)
gotoPrev	O(1)	O(n)	O(1)
getCursor	O(1)	O(1)	O(1)
showStructure	O(n)	O(n)	O(n)
moveToNth	O(n)	O(n)	O(n)
find	O(n)	O(n)	O(n)

1. 总结和收获

通过这个实验，首先练习三种数据结构，并学会了泛型，复习了内部类，学习了StreamTokenizer类的使用，学会了文件相关的方法和流。收获很大。

任务2

1. 题目

观察任务 1 中基于数组实现的线性表的测试用例的运行结果，发现大部分时候空间的使用率是不高的（length 和 capacity 的比值反映了这一事实），而且还存在有空间不够用的例外发生。当然，基于链式存储实现的线性表则不存在此类问题。为了解决空间利用率以及空间不够用的问题，任务 2 将使用动态调整的方式改善数组空间的大小，方案可以有很多种，但在本次实验中将采用如下的调整方案，具体步骤如下：

① 使用 capacity 表示当前线性表的最大容量（即最多能够存储的线性表元素个数）；

② 初始情况下，capacity=1；

③ 当插入元素时线性表满，那么就重新生成一个容量为 2*capacity 的数组，将原数组中的capacity 个元素拷贝到新数组中，让新数组成为当前线性表的存储表示；

④ 当删除元素之后，如果当前线性表中的元素个数 length 是 capacity 的四分之一时，则重新生成一个容量为 capacity/2 的数组，将原数组中的 length 个元素拷贝到新数组中，让新数组成为当前线性表的存储表示。

如果基于数组存储表示的线性表按照如上的方式完成空间的动态调整，那么构造方法中就不需要再指定初始空间的大小了。

该任务中需要完成的工作如下：

① 按照任务 1 中的 List 接口定义，实现一个 ResizingAList 线性表，数组空间的调整方案如该任务中所描述的；

② 继续使用“list_testcase.txt”进行测试，并将结果中的每行运行结果中当前线性表的空间使用率和任务 1 中的空间使用率用图的方式展示其变化过程。

1. 数据设计

ResizingAList和Array本质没有区别，只需要实现一个方法resizeStorage，根据传入的参数newCapacity重新生成一个数组，将原数组中的capacity 个元素拷贝到新数组中，让新数组成为当前线性表的存储表示即可。最开始数组大小为1，然后在insert和remove方法判断条件并调用即可。

resizeStorage方法：

1.     /**
2.      * 重新生成一个指定容量的数组，并将原数组中的元素拷贝到新数组中。
3.      *
4.      * @param newCapacity 新的数组容量。
5.      */
6.     private void resizeStorage(int newCapacity) {
7.         if (newCapacity < count) {
8.             throw new IllegalArgumentException("New capacity is too small to hold existing elements.");
9.         }
11.         T[] newStorage = (T[]) new Object[newCapacity];
12.         for (int i = 0; i < count; i++) {
13.             newStorage[i] = storage[i];
14.         }
16.         storage = newStorage;
17.         capacity = newCapacity;
18.     }

构造方法：

1.     //不带初始容量的构造方法。默认容量为1
2.     public DynamicArray() {
3.         this.capacity = 1;
4.         this.curr = -1;
5.         this.storage = (T[]) new Object[1];
6.         this.count = 0;
7.     }

Insert方法：

1.     /**
2.      * 在当前位置插入一个元素
3.      * 从curr开始的元素全部向后移动一位
4.      * curr指向被插入的元素
5.      */
6.     @Override
7.     public void insert(T newElement) throws ListException {
8.         //列表满了
9.         if (isFull()) {
10.             resizeStorage(capacity * 2);
11.         }
12.         if (curr < -1 || curr > capacity) {
13.             throw new ListException("插入位置不合适");
14.         }
15.         if(isEmpty()){
16.             curr = -1;
17.         }
18.         for (int i = count - 1; i > curr; i--) {
19.             storage[i + 1] = storage[i];
20.         }
21.         curr++;
22.         storage[curr] = newElement;
23.         count++;
24.     }

Remove方法：

1.     /**
2.      * 从列表中移除游标标记的元素
3.      * 如果结果列表不为空，则将光标移动到被删除元素后面的元素
4.      * 如果被删除的元素位于列表末尾，则将光标移动到列表开头的元素
5.      */
6.     @Override
7.     public void remove() {
8.         //如果列表不为空就把后面的元素前移就行，如果已经空了就不用管了
9.         if (!isEmpty()) {
10.             for (int i = curr + 1; i < count; i++) {
11.                 storage[i - 1] = storage[i];
12.             }
13.             count--;
14.             if (count == curr) {
15.                 curr = 0;
16.             }
18.             // 当删除元素后，检查是否需要缩小数组的容量
19.             if (count > 0 && count == capacity / 4) {
20.                 resizeStorage(capacity / 2);
21.             }
22.         }
23.     }

1. 算法设计

作出空间使用率的图的思路如下：

提供的文件有很多行命令行，每一行都会打印一个capacity和length，也就可以得到一个比值代表空间使用率，那么我们就将行数代表横轴，纵轴是空间使用率。

我们在Array和DynamicArray中各自写一个方法SpaceUsageOfArray，输出length/capacity表示空间使用率。

1.     public double SpaceUsageOfArray(){
2.         return (double) count / capacity;
3.     }

对于Array和DynamicArray，在每行读入数据处理后分别调用SpaceUsageOfArray得到空间使用率并储存进DynamicArray类型的UsageOfArray和UsageOfDynamicArray中，不直接导入数组的原因是我们无法知道行数是多少。

1.         String line;
2.         while ((line = br.readLine()) != null) {
3.             executeCommand(array, line);
4.             executeCommand(dynamicArray, line, writer);
6.             UsageOfArray.insert(array.SpaceUsageOfArray());
7.             UsageOfDynamicArray.insert(dynamicArray.SpaceUsageOfArray());
9.             writer.flush(); // 刷新PrintWriter的缓冲区
10.         }

因为空间使用率在DynamicArray类型的数组中，我们就得到了行数numberOfLine，并创建两个数组储存对应的数据，此时我们已经准备好了两个纵坐标的数据。我们再创建一个数组表示横坐标，储存从1到行数到数即可。

1.         int numberOfLine = UsageOfDynamicArray.getCount();
2.         re = new double[numberOfLine];//一共有125行横坐标有125个
3.         arrayUsageOfArray = new double[numberOfLine];
4.         arrayUsageOfDynamicArray = new double[numberOfLine];
5.         for (int i = 0; i < re.length; i++) {
6.             re[i] = i + 1;
7.         }
8.         UsageOfArray.gotoBeginning();
9.         for (int i = 0; i < arrayUsageOfArray.length; i++) {
10.             arrayUsageOfArray[i] = UsageOfArray.getCursor();
11.             UsageOfArray.gotoNext();
12.         }
13.         UsageOfDynamicArray.gotoBeginning();
14.         for (int i = 0; i < arrayUsageOfDynamicArray.length; i++) {
15.             arrayUsageOfDynamicArray[i] = UsageOfDynamicArray.getCursor();
16.             UsageOfDynamicArray.gotoNext();
17.         }

我们调用上次作业的代码作图即可。

1.         Draw demo = new Draw("UsageOfArray");
2.         demo.pack();
3.         demo.setVisible(true);

1. 运行结果展示

DynamicArray的测试用例额对应的测试结果（部分）

每行运行结果中当前线性表的空间使用率和任务 1 中的空间使用率用图的方式展示其变化过程：

DynamicArray和Array的空间利用率对比图

1. 总结和收获

可以看出来，动态数组的空间利用率远远大于静态数组。

复习了如何利用java作图，学习了动态数组和静态数组。

 

附录：

1. 任务1、2

1. 老师提供的List不再展示：
2. ListException:

1. package Homework0102;
3. public class ListException extends Throwable {
4.     public ListException(String message) {
5.         super(message);
6.     }
7. }

1. Array：

1. package Homework0102;
3. import java.io.PrintWriter;
4. import java.util.Arrays;
5. import java.util.Iterator;
7. public class Array<T> implements List<T>, Iterable<T> {
9.     private T[] storage;//储存的数组
10.     private int capacity;//容量
11.     private int count;//元素数量
12.     private int curr;//当前元素的位置
15.     //不带初始容量的构造方法。默认容量为512
16.     public Array() {
17.         this.capacity = 512;
18.         this.curr = -1;
19.         this.storage = (T[]) new Object[512];
20.         this.count = 0;
21.     }
23.     /**
24.      * 在当前位置插入一个元素
25.      * 从curr开始的元素全部向后移动一位
26.      * curr指向被插入的元素
27.      */
28.     @Override
29.     public void insert(T newElement) throws ListException {
30.         //列表满了
31.         if (isFull()) {
32.             return;
33.         }
34.         if (curr < -1 || curr > capacity) {
35.             throw new ListException("插入位置不合适");
36.         }
37.         if(isEmpty()){
38.             curr = -1;
39.         }
40.         for (int i = count - 1; i > curr; i--) {
41.             storage[i + 1] = storage[i];
42.         }
43.         curr++;
44.         storage[curr] = newElement;
45.         count++;
46.     }
48.     /**
49.      * 从列表中移除游标标记的元素
50.      * 如果结果列表不为空，则将光标移动到被删除元素后面的元素
51.      * 如果被删除的元素位于列表末尾，则将光标移动到列表开头的元素
52.      */
53.     @Override
54.     public void remove() {
55.         //如果列表不为空就把后面的元素前移就行，如果已经空了就不用管了
56.         if (!isEmpty()) {
57.             for (int i = curr + 1; i < count; i++) {
58.                 storage[i - 1] = storage[i];
59.             }
60.             count--;
61.             if (count == curr) {
62.                 curr = 0;
63.             }
64.         }
65.     }
67.     /**
68.      * 先决条件：List不为空，newElement也不为空。
69.      * 后置条件：用newElement替换游标标记的元素。游标保持在newElement处
70.      */
71.     @Override
72.     public void replace(T newElement) {
73.         if(isEmpty()){
74.             return;
75.         }
76.         storage[curr] = newElement;
77.     }
79.     //删除列表中所有元素
80.     @Override
81.     public void clear() {
82.         Arrays.fill(storage, 0, count, null);  // 将数组中的元素设为null
83.         count = curr = 0;//元素清空
84.     }
86.     @Override
87.     public boolean isEmpty() {
88.         return count == 0;
89.     }
91.     @Override
92.     public boolean isFull() {
93.         return count == capacity;
94.     }
96.     //如果列表不为空，则将光标移动到列表的开头并返回true。否则,返回false。
97.     @Override
98.     public boolean gotoBeginning() {
99.         if (!isEmpty()) {
100.             curr = 0;
101.             return true;
102.         } else {
103.             return false;
104.         }
105.     }
107.     @Override
108.     public boolean gotoEnd() {
109.         if (!isEmpty()) {
110.             curr = count - 1;
111.             return true;
112.         } else {
113.             return false;
114.         }
115.     }
117.     @Override
118.     public boolean gotoNext() {
119.         if (isEmpty() || curr == count - 1) {
120.             return false;
121.         }
122.         curr++;
123.         return true;
124.     }
126.     @Override
127.     public boolean gotoPrev() {
128.         if (isEmpty() || curr == 0) {
129.             return false;
130.         }
131.         curr--;
132.         return true;
133.     }
135.     /**
136.      * 前提条件: List不为空。
137.      * 返回游标所标记元素的副本。
138.      */
139.     @Override
140.     public T getCursor() {
141.         return storage[curr];
142.     }
144.     /**
145.      * 输出列表中的元素和游标的值。
146.      * 如果列表为空，则输出“empty list”。
147.      * 注意，此操作仅用于测试/调试目的。
148.      */
149.     @Override
150.     public void showStructure(PrintWriter pw) {
151.         int current = curr;
152.         if (isEmpty()) {
153.             pw.print("Empty list ");
154.             pw.print("{capacity = ");
155.             pw.print(capacity);
156.             pw.print(", length = ");
157.             pw.print(count);
158.             pw.print(", cursor = ");
159.             pw.print(-1);
160.             pw.println("}");
161.         } else {
162.             gotoBeginning();
163.             for (int i = 0; i < count; i++) {
164.                 pw.print(storage[i] + " ");
165.             }
166.             curr = current;
167.             pw.print("{capacity = ");
168.             pw.print(capacity);
169.             pw.print(", length = ");
170.             pw.print(count);
171.             pw.print(", cursor = ");
172.             pw.print(curr);
173.             pw.println("}");
174.         }
175.     }
177.     public double SpaceUsageOfArray(){
178.         return (double) count / capacity;
179.     }
182.     /**
183.      * 前提条件:列表至少包含n + 1个元素。
184.      * 从列表中删除游标标记的元素
185.      * 并将其作为列表中的第n个元素重新插入
186.      * 其中的元素从0开始从头到尾编号
187.      * 将光标移动到被移动的元素。
188.      */
189.     @Override
190.     public void moveToNth(int n) throws ListException {
191.         if (count < n + 1) {
192.             System.out.println("输入的n过大");
193.             return;
194.         }
195.         T removed = getCursor();
196.         remove();
197.         gotoN(n);
198.         insert(removed);
199.     }
201.     /**
202.      * 前提条件: List不为空。
203.      * 在列表中搜索searchElement。
204.      * 从游标标记的元素开始搜索。在列表中移动光标，直到找到searchElement(返回true)
205.      * 或到达列表末尾而没有找到searchElement(返回false)。
206.      * 将游标留在搜索期间访问的最后一个元素处。
207.      */
208.     @Override
209.     public boolean find(T searchElement) {
210.         while (curr <= count) {
211.             if(storage[curr] == searchElement){
212.                 return true;
213.             }
214.             curr++;
215.         }
216.         return false;
217.     }
219.     @Override
220.     public Iterator<T> iterator() {
221.         curr = 0;
222.         return new Iterator<T>() {
223.             @Override
224.             public boolean hasNext() {
225.                 return curr < count;
226.             }
228.             @Override
229.             public T next() {
230.                 T value = storage[curr];
231.                 curr++;
232.                 return value;
233.             }
234.         };
235.     }
238.     public void gotoN(int n) {
239.         gotoBeginning();
240.         for (int i = 0; i < n; i++) {
241.             gotoNext();
242.         }
243.     }
244. }

1. SingleLinkedListSentinel：

1. package Homework0102;
3. import java.io.PrintWriter;
4. import java.util.Iterator;
6. //单向链表带头尾哨兵
7. public class SingleLinkedListSentinel<T> implements List<T>, Iterable<T> {
9.     private static class Node<T> {
10.         T value;
11.         Node<T> next;
13.         public Node(T value, Node<T> next) {
14.             this.value = value;
15.             this.next = next;
16.         }
17.     }
19.     //两个哨兵节点
20.     private Node<T> head;
21.     private Node<T> tail;
22.     private Node<T> p;//指针
24.     public SingleLinkedListSentinel() {
25.         head = new Node<T>(null, null);
26.         tail = new Node<T>(null, null);
27.         head.next = tail;
28.         p = head;
29.     }
31.     /**
32.      * 前提条件:List不满且newElement不为空。
33.      * 后置条件:
34.      * 将newElement插入到游标后面的列表中。如果列表为空，则插入newElement作为列表中的第一个(也是唯一一个)元素。
35.      * 在两种情况下(空或不空)，将光标移动到newElement。
36.      * 如果列表中没有足够的空间，抛出一个ListException异常。
37.      */
38.     @Override
39.     public void insert(T newElement) throws ListException {
40.         Node<T> added = new Node<>(newElement, p.next);
41.         p.next = added;
42.         p = added;
43.     }
45.     /**
46.      * 先决条件:
47.      * 列表不是空的。
48.      * 后置条件:
49.      * 从列表中移除游标标记的元素。如果结果列表不为空，
50.      * 然后将光标移动到被删除元素后面的元素。如果删除的元素
51.      * 位于列表末尾，然后将光标移动到列表开头的元素。
52.      */
53.     @Override
54.     public void remove() {
55.         if (!isEmpty()) {
56.             gotoPrev();
57.             p.next = p.next.next;
58.             gotoNext();
59.             if (p.next == tail) {
60.                 gotoBeginning();
61.             }
62.         }
63.     }
65.     /**
66.      * 先决条件:
67.      * List不为空，newElement也不为空。
68.      * 后置条件:
69.      * 用newElement替换游标标记的元素。游标保持在newElement处。
70.      */
71.     @Override
72.     public void replace(T newElement) {
73.         p.value = newElement;
74.     }
76.     /**
77.      * 先决条件:
78.      * 没有
79.      * 后置条件:
80.      * 删除列表中的所有元素。
81.      */
82.     @Override
83.     public void clear() {
84.         head.next = tail;
85.         p = head;
86.     }
88.     @Override
89.     public boolean isEmpty() {
90.         return head.next == tail;
91.     }
93.     @Override
94.     public boolean isFull() {
95.         return false;
96.     }
98.     @Override
99.     public boolean gotoBeginning() {
100.         if (!isEmpty()) {
101.             p = head.next;
102.             return true;
103.         } else {
104.             return false;
105.         }
106.     }
108.     @Override
109.     public boolean gotoEnd() {
110.         if (!isEmpty()) {
111.             Node<T> pi = head.next;
112.             while (pi.next != tail) {
113.                 pi = pi.next;
114.             }
115.             p = pi;
116.             return true;
117.         } else {
118.             return false;
119.         }
120.     }
122.     @Override
123.     public boolean gotoNext() {
124.         if (p.next != tail) {
125.             p = p.next;
126.             return true;
127.         } else {
128.             return false;
129.         }
130.     }
132.     @Override
133.     public boolean gotoPrev() {
134.         if (p == head || p == null) {
135.             return false; // 已经是第一个节点或者p为空
136.         } else {
137.             Node<T> pi = head;
138.             while (pi.next != p) {
139.                 pi = pi.next;
140.                 if (pi == null) { // 如果已经到达链表尾部，说明p不是链表中的节点
141.                     return false;
142.                 }
143.             }
144.             p = pi; // 现在pi就是p的前一个节点
145.             return true;
146.         }
147.     }
149.     /**
150.      * 先决条件:
151.      * 列表不是空的。
152.      * 后置条件:
153.      * 返回由游标标记的元素的副本。
154.      */
155.     @Override
156.     public T getCursor() {
157.         return p.value;
158.     }
160.     /**
161.      * 先决条件:
162.      * 没有
163.      * 后置条件:
164.      * 输出列表中的元素和光标的值。如果列表为空，则输出“empty list”。
165.      * 注意，此操作仅用于测试/调试目的。
166.      */
167.     @Override
168.     public void showStructure(PrintWriter pw) {
169.         if (isEmpty()) {
170.             pw.print("Empty list ");
171.             pw.println("{capacity = 0, length = 0, cursor = -1}");
172.         } else {
173.             Node<T> pi = p;
174.             int current = getN(p);
175.             gotoEnd();
176.             int capacity = getN(p) + 1;
178.             gotoBeginning();
179.             while (p != tail) {
180.                 pw.print(p.value + " ");
181.                 p = p.next;
182.             }
183.             pw.print("{capacity = ");
184.             pw.print(capacity);
185.             pw.print(", length = ");
186.             pw.print(capacity);
187.             pw.print(", cursor = ");
188.             pw.print(current);
189.             pw.println("}");
190.             p = pi;
191.         }
192.     }
194.     /**
195.      * 先决条件:
196.      * 列表至少包含n + 1个元素。
197.      * 后置条件:
198.      * 从列表中删除被游标标记的元素，并将其作为列表中的第n个元素重新插入，其中的元素从0开始从头到尾编号。将光标移动到被移动的元素。
199.      */
200.     @Override
201.     public void moveToNth(int n) {
202.         Node<T> pi = p;
203.         remove();
204.         gotoBeginning();
205.         for (int i = 0; i < n; i++) {
206.             p = p.next;
207.         }
208.         pi.next = p.next;
209.         p.next = pi;
210.         p = p.next;
211.     }
213.     /**
214.      * 先决条件:
215.      * 列表不是空的。
216.      * 后置条件:
217.      * 在列表中搜索searchElement。从游标标记的元素开始搜索。在列表中移动光标，直到找到searchElement(返回true)或到达列表末尾而没有找到searchElement(返回false)。将游标留在搜索期间访问的最后一个元素处。
218.      */
219.     @Override
220.     public boolean find(T searchElement) {
221.         if (isEmpty()) {
222.             return false;
223.         } else {
224.             while (p != tail) { // 当未到达链表末尾时，继续搜索
225.                 if (p.value.equals(searchElement)) { // 如果找到元素，返回true
226.                     return true;
227.                 }
228.                 p = p.next; // 移动到下一个节点
229.             }
230.             return false; // 如果到达链表末尾仍未找到元素，返回false
231.         }
232.     }
234.     private int getN(Node<T> p) {
235.         if (head == null) { // 链表为空
236.             return -1;
237.         }
238.         Node<T> pi = head;
239.         int i = 0;
240.         while (pi != null && p != pi.next) { // 检查pi是否为null
241.             pi = pi.next;
242.             i++;
243.         }
244.         // 如果pi为null，说明p不在链表中或者链表已经遍历完
245.         if (pi == null) {
246.             return -1;
247.         }
248.         return i;
249.     }
251.     @Override
252.     public Iterator<T> iterator() {
253.         return new Iterator<T>() {
254.             Node<T> p = head.next;
256.             @Override
257.             public boolean hasNext() {
258.                 return p != tail;
259.             }
261.             @Override
262.             public T next() {
263.                 T value = p.value;
264.                 p = p.next;
265.                 return value;
266.             }
267.         };
268.     }
269. }

1. DoubleLinkedListSentinel：

1. package Homework0102;
3. import java.io.PrintWriter;
4. import java.util.Iterator;
6. //双向链表带头尾哨兵
7. public class DoubleLinkedListSentinel<T> implements List<T>, Iterable<T> {
9.     private static class Node<T> {
10.         T value;
11.         Node<T> next;
12.         Node<T> prev;
14.         public Node(T value, Node<T> next, Node<T> prev) {
15.             this.value = value;
16.             this.next = next;
17.             this.prev = prev;
18.         }
19.     }
21.     //两个哨兵节点
22.     private Node<T> head;
23.     private Node<T> tail;
24.     private Node<T> p;//指针
26.     public DoubleLinkedListSentinel() {
27.         head = new Node<T>(null, null, null);
28.         tail = new Node<T>(null, null, null);
29.         head.next = tail;
30.         tail.prev = head;
31.         p = head;
32.     }
34.     /**
35.      * 前提条件:List不满且newElement不为空。
36.      * 后置条件:
37.      * 将newElement插入到游标后面的列表中。如果列表为空，则插入newElement作为列表中的第一个(也是唯一一个)元素。
38.      * 在两种情况下(空或不空)，将光标移动到newElement。
39.      * 如果列表中没有足够的空间，抛出一个ListException异常。
40.      */
41.     @Override
42.     public void insert(T newElement) throws ListException {
43.         Node<T> next = p.next;
44.         Node<T> added = new Node<>(newElement, p.next, p);
45.         next.prev = added;
46.         p.next = added;
47.         p = added;
48.     }
50.     /**
51.      * 先决条件:
52.      * 列表不是空的。
53.      * 后置条件:
54.      * 从列表中移除游标标记的元素。如果结果列表不为空，
55.      * 然后将光标移动到被删除元素后面的元素。如果删除的元素
56.      * 位于列表末尾，然后将光标移动到列表开头的元素。
57.      */
58.     @Override
59.     public void remove() {
60.         if (!isEmpty()) {
61.             Node<T> prev = p.prev;
62.             Node<T> next = p.next;
63.             prev.next = next;
64.             next.prev = prev;
65.             p = next;
66.             if(p == tail && !isEmpty()){
67.                 gotoBeginning();
68.             } else if (p == tail && isEmpty()) {
69.                 p = head;
70.             }
71.         }
72.     }
74.     /**
75.      * 先决条件:
76.      * List不为空，newElement也不为空。
77.      * 后置条件:
78.      * 用newElement替换游标标记的元素。游标保持在newElement处。
79.      */
80.     @Override
81.     public void replace(T newElement) {
82.         if (!isEmpty() && newElement != null) {
83.             p.value = newElement;
84.         }
85.     }
87.     /**
88.      * 先决条件:
89.      * 没有
90.      * 后置条件:
91.      * 删除列表中的所有元素。
92.      */
93.     @Override
94.     public void clear() {
95.         head.next = tail;
96.         tail.prev = head;
97.         p = head;
98.     }
100.     @Override
101.     public boolean isEmpty() {
102.         return head.next == tail;
103.     }
105.     @Override
106.     public boolean isFull() {
107.         return false;
108.     }
110.     @Override
111.     public boolean gotoBeginning() {
112.         if (!isEmpty()) {
113.             p = head.next;
114.             return true;
115.         } else {
116.             return false;
117.         }
118.     }
120.     @Override
121.     public boolean gotoEnd() {
122.         if (!isEmpty()) {
123.             p = tail.prev;
124.             return true;
125.         } else {
126.             return false;
127.         }
128.     }
130.     @Override
131.     public boolean gotoNext() {
132.         if(isEmpty()){
133.             return false;
134.         }
135.         if (p.next != tail) {
136.             p = p.next;
137.             return true;
138.         } else {
139.             return false;
140.         }
141.     }
143.     @Override
144.     public boolean gotoPrev() {
145.         if(isEmpty()){
146.             return false;
147.         }
148.         if (p.prev != head) {
149.             p = p.prev;
150.             return true;
151.         } else {
152.             return false;
153.         }
154.     }
156.     /**
157.      * 先决条件:
158.      * 列表不是空的。
159.      * 后置条件:
160.      * 返回由游标标记的元素的副本。
161.      */
162.     @Override
163.     public T getCursor() {
164.         if (!isEmpty()) {
165.             return p.value;
166.         }
167.         return null;
168.     }
170.     /**
171.      * 先决条件:
172.      * 没有
173.      * 后置条件:
174.      * 输出列表中的元素和光标的值。如果列表为空，则输出“empty list”。
175.      * 注意，此操作仅用于测试/调试目的。
176.      */
177.     @Override
178.     public void showStructure(PrintWriter pw) {
179.         if (isEmpty()) {
180.             pw.print("Empty list ");
181.             pw.println("{capacity = 0, length = 0, cursor = -1}");
182.         } else {
183.             Node<T> pi = p;
184.             int current = getN(p);
185.             gotoEnd();
186.             int capacity = getN(p) + 1;
187.             gotoBeginning();
188.             while (p != tail) {
189.                 pw.print(p.value + " ");
190.                 p = p.next;
191.             }
192.             pw.print("{capacity = ");
193.             pw.print(capacity);
194.             pw.print(", length = ");
195.             pw.print(capacity);
196.             pw.print(", cursor = ");
197.             pw.print(current);
198.             pw.println("}");
200.             p = pi;
201.         }
202.     }
204.     private int getN(Node<T> p) {
205.         if (head == null) { // 链表为空
206.             return -1;
207.         }
208.         Node<T> pi = head;
209.         int i = 0;
210.         while (pi != null && p != pi.next) { // 检查pi是否为null
211.             pi = pi.next;
212.             i++;
213.         }
214.         // 如果pi为null，说明p不在链表中或者链表已经遍历完
215.         if (pi == null) {
216.             return -1;
217.         }
218.         return i;
219.     }
221.     /**
222.      * 先决条件:
223.      * 列表至少包含n + 1个元素。
224.      * 后置条件:
225.      * 从列表中删除被游标标记的元素，并将其作为列表中的第n个元素重新插入，其中的元素从0开始从头到尾编号。将光标移动到被移动的元素。
226.      */
227.     @Override
228.     public void moveToNth(int n) {
229.         Node<T> pi = p;
230.         remove();
231.         gotoBeginning();
232.         for (int i = 0; i < n; i++) {
233.             p = p.next;
234.         }
235.         Node<T> pj = p.next;
236.         pi.next = p.next;
237.         p.next = pi;
238.         pj.prev = pi;
239.         pi.prev = p;
240.         p = p.next;
241.     }
243.     /**
244.      * 先决条件:
245.      * 列表不是空的。
246.      * 后置条件:
247.      * 在列表中搜索searchElement。从游标标记的元素开始搜索。在列表中移动光标，直到找到searchElement(返回true)或到达列表末尾而没有找到searchElement(返回false)。将游标留在搜索期间访问的最后一个元素处。
248.      */
249.     @Override
250.     public boolean find(T searchElement) {
251.         if (isEmpty()) {
252.             return false;
253.         } else {
254.             while (p != tail) { // 当未到达链表末尾时，继续搜索
255.                 if (p.value.equals(searchElement)) { // 如果找到元素，返回true
256.                     return true;
257.                 }
258.                 p = p.next; // 移动到下一个节点
259.             }
260.             return false; // 如果到达链表末尾仍未找到元素，返回false
261.         }
262.     }
264.     @Override
265.     public Iterator<T> iterator() {
266.         return new Iterator<T>() {
267.             Node<T> p = head.next;
269.             @Override
270.             public boolean hasNext() {
271.                 return p != tail;
272.             }
274.             @Override
275.             public T next() {
276.                 T value = p.value;
277.                 p = p.next;
278.                 return value;
279.             }
280.         };
281.     }
282. }

1. DynamicArray：

1. package Homework0102;
3. import java.io.PrintWriter;
4. import java.util.Arrays;
5. import java.util.Iterator;
7. public class DynamicArray<T> implements List<T>, Iterable<T> {
9.     private T[] storage;//储存的数组
10.     private int capacity;//容量
11.     private int count;//元素数量
12.     private int curr;//当前元素的位置
15.     //不带初始容量的构造方法。默认容量为1
16.     public DynamicArray() {
17.         this.capacity = 1;
18.         this.curr = -1;
19.         this.storage = (T[]) new Object[1];
20.         this.count = 0;
21.     }
23.     /**
24.      * 在当前位置插入一个元素
25.      * 从curr开始的元素全部向后移动一位
26.      * curr指向被插入的元素
27.      */
28.     @Override
29.     public void insert(T newElement) throws ListException {
30.         //列表满了
31.         if (isFull()) {
32.             resizeStorage(capacity * 2);
33.         }
34.         if (curr < -1 || curr > capacity) {
35.             throw new ListException("插入位置不合适");
36.         }
37.         if(isEmpty()){
38.             curr = -1;
39.         }
40.         for (int i = count - 1; i > curr; i--) {
41.             storage[i + 1] = storage[i];
42.         }
43.         curr++;
44.         storage[curr] = newElement;
45.         count++;
46.     }
48.     /**
49.      * 从列表中移除游标标记的元素
50.      * 如果结果列表不为空，则将光标移动到被删除元素后面的元素
51.      * 如果被删除的元素位于列表末尾，则将光标移动到列表开头的元素
52.      */
53.     @Override
54.     public void remove() {
55.         //如果列表不为空就把后面的元素前移就行，如果已经空了就不用管了
56.         if (!isEmpty()) {
57.             for (int i = curr + 1; i < count; i++) {
58.                 storage[i - 1] = storage[i];
59.             }
60.             count--;
61.             if (count == curr) {
62.                 curr = 0;
63.             }
65.             // 当删除元素后，检查是否需要缩小数组的容量
66.             if (count > 0 && count == capacity / 4) {
67.                 resizeStorage(capacity / 2);
68.             }
69.         }
70.     }
72.     /**
73.      * 重新生成一个指定容量的数组，并将原数组中的元素拷贝到新数组中。
74.      *
75.      * @param newCapacity 新的数组容量。
76.      */
77.     private void resizeStorage(int newCapacity) {
78.         if (newCapacity < count) {
79.             throw new IllegalArgumentException("New capacity is too small to hold existing elements.");
80.         }
82.         T[] newStorage = (T[]) new Object[newCapacity];
83.         for (int i = 0; i < count; i++) {
84.             newStorage[i] = storage[i];
85.         }
87.         storage = newStorage;
88.         capacity = newCapacity;
89.     }
91.     /**
92.      * 先决条件：List不为空，newElement也不为空。
93.      * 后置条件：用newElement替换游标标记的元素。游标保持在newElement处
94.      */
95.     @Override
96.     public void replace(T newElement) {
97.         if(!isEmpty()){
98.             storage[curr] = newElement;
99.         }
100.     }
102.     //删除列表中所有元素
103.     @Override
104.     public void clear() {
105.         Arrays.fill(storage, 0, count, null);  // 将数组中的元素设为null
106.         count = curr = 0;  // 元素数量和当前位置重置为0
107.         capacity = 1;  // 容量重置为初始值
108.         storage = (T[]) new Object[capacity];  // 重新创建一个新的数组
109.     }
111.     @Override
112.     public boolean isEmpty() {
113.         return count == 0;
114.     }
116.     @Override
117.     public boolean isFull() {
118.         return count == capacity;
119.     }
121.     //如果列表不为空，则将光标移动到列表的开头并返回true。否则,返回false。
122.     @Override
123.     public boolean gotoBeginning() {
124.         if (!isEmpty()) {
125.             curr = 0;
126.             return true;
127.         } else {
128.             return false;
129.         }
130.     }
132.     //
133.     @Override
134.     public boolean gotoEnd() {
135.         if (!isEmpty()) {
136.             curr = count - 1;
137.             return true;
138.         } else {
139.             return false;
140.         }
141.     }
143.     @Override
144.     public boolean gotoNext() {
145.         if (isEmpty() || curr == count - 1) {
146.             return false;
147.         }
148.         curr++;
149.         return true;
150.     }
152.     @Override
153.     public boolean gotoPrev() {
154.         if (isEmpty() || curr == 0) {
155.             return false;
156.         }
157.         curr--;
158.         return true;
159.     }
161.     /**
162.      * 前提条件: List不为空。
163.      * 返回游标所标记元素的副本。
164.      */
165.     @Override
166.     public T getCursor() {
167.         return storage[curr];
168.     }
170.     /**
171.      * 输出列表中的元素和游标的值。
172.      * 如果列表为空，则输出“empty list”。
173.      * 注意，此操作仅用于测试/调试目的。
174.      */
175.     @Override
176.     public void showStructure(PrintWriter pw) {
177.         int current = curr;
178.         if (isEmpty()) {
179.             pw.print("Empty list");
180.             pw.print("{capacity = ");
181.             pw.print(capacity);
182.             pw.print(", length = ");
183.             pw.print(count);
184.             pw.print(", cursor = ");
185.             pw.print(-1);
186.             pw.println("}");
187.         } else {
188.             gotoBeginning();
189.             for (int i = 0; i < count; i++) {
190.                 pw.print(storage[i] + " ");
191.             }
192.             curr = current;
193.             pw.print("{capacity = ");
194.             pw.print(capacity);
195.             pw.print(", length = ");
196.             pw.print(count);
197.             pw.print(", cursor = ");
198.             pw.print(curr);
199.             pw.println("}");
200.         }
201.     }
203.     public int getCount() {
204.         return count;
205.     }
207.     public double SpaceUsageOfArray(){
208.         if(isEmpty()){
209.             return 1.0;
210.         }
211.         return (double) count / capacity;
212.     }
214.     /**
215.      * 前提条件:列表至少包含n + 1个元素。
216.      * 从列表中删除游标标记的元素
217.      * 并将其作为列表中的第n个元素重新插入
218.      * 其中的元素从0开始从头到尾编号
219.      * 将光标移动到被移动的元素。
220.      */
221.     @Override
222.     public void moveToNth(int n) throws ListException {
223.         if (count < n + 1) {
224.             System.out.println("输入的n过大");
225.             return;
226.         }
227.         T removed = getCursor();
228.         remove();
229.         gotoN(n);
230.         insert(removed);
231.     }
233.     /**
234.      * 前提条件: List不为空。
235.      * 在列表中搜索searchElement。
236.      * 从游标标记的元素开始搜索。在列表中移动光标，直到找到searchElement(返回true)
237.      * 或到达列表末尾而没有找到searchElement(返回false)。
238.      * 将游标留在搜索期间访问的最后一个元素处。
239.      */
240.     @Override
241.     public boolean find(T searchElement) {
242.         while (curr <= count) {
243.             if (storage[curr] == searchElement) {
244.                 return true;
245.             }
246.             curr++;
247.         }
248.         return false;
249.     }
251.     @Override
252.     public Iterator<T> iterator() {
253.         curr = 0;
254.         return new Iterator<T>() {
255.             @Override
256.             public boolean hasNext() {
257.                 return curr < count;
258.             }
260.             @Override
261.             public T next() {
262.                 T value = storage[curr];
263.                 curr++;
264.                 return value;
265.             }
266.         };
267.     }
270.     public void gotoN(int n) {
271.         gotoBeginning();
272.         for (int i = 0; i < n; i++) {
273.             gotoNext();
274.         }
275.     }
276. }

1. 测试类FileTest：

1. package Homework0102;
3. import java.io.*;
5. public class FileTest {
6.     public static void main(String[] args) throws IOException, ListException {
8.         DynamicArray<Object> array = new DynamicArray<>();
10.         FileReader fis = new FileReader("D:\\develop\\projects\\dataStructure\\homework02\\src\\Homework0102\\list_testcase.txt");
11.         BufferedReader br = new BufferedReader(fis);
13.         PrintWriter writer = new PrintWriter(System.out); // 创建PrintWriter对象
15.         String line;
16.         while ((line = br.readLine()) != null) {
17.             executeCommand(array, line);
18.             array.showStructure(writer); // 调用array.showStructure(writer)显示列表结构
19.             writer.flush(); // 刷新PrintWriter的缓冲区
20.         }
22.         writer.close(); // 在循环结束后关闭PrintWriter对象
23.     }
25.     private static void executeCommand(DynamicArray<Object> array, String line) throws ListException, IOException {
26.         StreamTokenizer st = new StreamTokenizer(new StringReader(line));
27.         int token = st.nextToken();
28.         while (token != StreamTokenizer.TT_EOF) {
29.             char command = (char) st.ttype;
30.             switch (command) {
31.                 case '+' -> {
32.                     st.nextToken();
33.                     array.insert(st.sval);
34.                 }
35.                 case '-' -> array.remove();
36.                 case '=' -> {
37.                     st.nextToken();
38.                     array.replace(st.sval);
39.                 }
40.                 case '#' -> array.gotoBeginning();
41.                 case '*' -> array.gotoEnd();
42.                 case '>' -> array.gotoNext();
43.                 case '<' -> array.gotoPrev();
44.                 case '~' -> array.clear();
45.             }
46.             token = st.nextToken();
47.         }
48.     }
49. }

1. 文件比较类TextFileComparator：

1. package Homework0102;
2. import java.io.BufferedReader;
3. import java.io.FileReader;
4. import java.io.IOException;
6. public class TextFileComparator {
7.     public static boolean compareFiles(String filePath1, String filePath2) {
8.         try (BufferedReader reader1 = new BufferedReader(new FileReader(filePath1));
9.              BufferedReader reader2 = new BufferedReader(new FileReader(filePath2))) {
10.             String line1, line2;
11.             while ((line1 = reader1.readLine()) != null) {
12.                 line2 = reader2.readLine();
13.                 if (!line1.equals(line2)) {
14.                     return false;
15.                 }
16.             }
17.             // Check if file2 has additional lines
18.             return reader2.readLine() == null;
19.         } catch (IOException e) {
20.             e.printStackTrace();
21.             return false;
22.         }
23.     }
25.     public static void main(String[] args) {
26.         String file1 = "D:\\develop\\projects\\dataStructure\\homework02\\src\\Homework0102\\list_result.txt";
27.         String file2 = "D:\\develop\\projects\\dataStructure\\homework02\\src\\Homework0102\\output.txt";
29.         boolean areEqual = compareFiles(file1, file2);
30.         if (areEqual) {
31.             System.out.println("两个文件的内容相同");
32.         } else {
33.             System.out.println("两个文件的内容不同");
34.         }
35.     }
36. }

1. 作图类Draw：

1. package Homework0102;
3. import org.jfree.chart.ChartFactory;
4. import org.jfree.chart.ChartPanel;
5. import org.jfree.chart.JFreeChart;
6. import org.jfree.chart.plot.PlotOrientation;
7. import org.jfree.chart.plot.XYPlot;
8. import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
9. import org.jfree.chart.ui.ApplicationFrame;
10. import org.jfree.chart.ui.RectangleInsets;
11. import org.jfree.data.xy.XYDataset;
12. import org.jfree.data.xy.XYSeries;
13. import org.jfree.data.xy.XYSeriesCollection;
15. import java.awt.*;
16. import java.io.*;
19. public class Draw extends ApplicationFrame {
20.     static DynamicArray<Double> UsageOfArray = new DynamicArray<>();
21.     static DynamicArray<Double> UsageOfDynamicArray = new DynamicArray<>();
22.     static double[] arrayUsageOfArray;
23.     static double[] arrayUsageOfDynamicArray;
24.     static double[] re;
26.     // 该构造方法中完成了数据集、图表对象和显示图表面板的创建工作
27.     public Draw(String title) {
28.         super(title);
29.         XYDataset dataset = createDataset();             // 创建记录图中坐标点的数据集
30.         JFreeChart chart = createChart(dataset);         // 使用上一步已经创建好的数据集生成一个图表对象
31.         ChartPanel chartPanel = new ChartPanel(chart);   // 将上一步已经创建好的图表对象放置到一个可以显示的Panel上
32.         // 设置GUI面板Panel的显示大小
33.         chartPanel.setPreferredSize(new Dimension(500, 270));
34.         setContentPane(chartPanel);                      // 这是JavaGUI的步骤之一，不用过于关心，面向对象课程综合训练的视频中进行了讲解。
35.     }
37.     private JFreeChart createChart(XYDataset dataset) {
38.         // 使用已经创建好的dataset生成图表对象
39.         // JFreechart提供了多种类型的图表对象，本次实验是需要使用XYLine型的图表对象
40.         JFreeChart chart = ChartFactory.createXYLineChart(
41.                 "Space usage of the array",// 图表的标题
42.                 "order",     // 横轴的标题名
43.                 "Space usage of the array",                        // 纵轴的标题名
44.                 dataset,                        // 图表对象中使用的数据集对象
45.                 PlotOrientation.VERTICAL,       // 图表显示的方向
46.                 true,                           // 是否显示图例
47.                 false,                          // 是否需要生成tooltips
48.                 false                           // 是否需要生成urls
49.         );
50.         // 下面所做的工作都是可选操作，主要是为了调整图表显示的风格
51.         // 同学们不必在意下面的代码
52.         // 可以将下面的代码去掉对比一下显示的不同效果
53.         chart.setBackgroundPaint(Color.WHITE);
54.         XYPlot plot = (XYPlot) chart.getPlot();
55.         plot.setBackgroundPaint(Color.lightGray);
56.         plot.setAxisOffset(new RectangleInsets(5.0, 5.0, 5.0, 6.0));
57.         plot.setDomainGridlinePaint(Color.WHITE);
58.         plot.setRangeGridlinePaint(Color.WHITE);
59.         XYLineAndShapeRenderer renderer = (XYLineAndShapeRenderer) plot.getRenderer();
60.         renderer.setDefaultShapesVisible(true);
61.         renderer.setDefaultShapesFilled(true);
62.         return chart;
63.     }
65.     private XYDataset createDataset() {
66.         double[][] Y = {arrayUsageOfArray, arrayUsageOfDynamicArray};
67.         XYSeries[] series = {new XYSeries("array"), new XYSeries("dynamic array")};
68.         int N = re.length;
69.         int M = series.length;
70.         System.out.println(M);
71.         System.out.println(N);
72.         for (int i = 0; i < M; i++)
73.             for (int j = 0; j < N; j++)
74.                 series[i].add(re[j], Y[i][j]);
76.         // 因为在该图表中显示的数据序列不止一组，所以在jfreechart中需要将多组数据序列存放到一个XYSeriesCollection对象中
77.         XYSeriesCollection dataset = new XYSeriesCollection();
78.         for (int i = 0; i < M; i++)
79.             dataset.addSeries(series[i]);
81.         return dataset;
82.     }
84.     public static void main(String[] args) throws IOException, ListException {
86.         DynamicArray<Object> dynamicArray = new DynamicArray<>();
87.         Array<Object> array = new Array<>();
89.         FileReader fis = new FileReader("D:\\develop\\projects\\dataStructure\\homework02\\src\\Homework0102\\list_testcase.txt");
90.         BufferedReader br = new BufferedReader(fis);
92.         PrintWriter writer = new PrintWriter(System.out); // 创建PrintWriter对象
94.         String line;
95.         while ((line = br.readLine()) != null) {
96.             executeCommand(array, line);
97.             executeCommand(dynamicArray, line, writer);
99.             UsageOfArray.insert(array.SpaceUsageOfArray());
100.             UsageOfDynamicArray.insert(dynamicArray.SpaceUsageOfArray());
102.             writer.flush(); // 刷新PrintWriter的缓冲区
103.         }
105.         int numberOfLine = UsageOfDynamicArray.getCount();
106.         re = new double[numberOfLine];//一共有125行横坐标有125个
107.         arrayUsageOfArray = new double[numberOfLine];
108.         arrayUsageOfDynamicArray = new double[numberOfLine];
109.         for (int i = 0; i < re.length; i++) {
110.             re[i] = i + 1;
111.         }
112.         UsageOfArray.gotoBeginning();
113.         for (int i = 0; i < arrayUsageOfArray.length; i++) {
114.             arrayUsageOfArray[i] = UsageOfArray.getCursor();
115.             UsageOfArray.gotoNext();
116.         }
117.         UsageOfDynamicArray.gotoBeginning();
118.         for (int i = 0; i < arrayUsageOfDynamicArray.length; i++) {
119.             arrayUsageOfDynamicArray[i] = UsageOfDynamicArray.getCursor();
120.             UsageOfDynamicArray.gotoNext();
121.         }
122.         writer.close(); // 在循环结束后关闭PrintWriter对象
123.         Draw demo = new Draw("UsageOfArray");
124.         demo.pack();
125.         demo.setVisible(true);
126.     }
128.     private static void executeCommand(Array<Object> array, String line) throws ListException, IOException {
129.         StreamTokenizer st = new StreamTokenizer(new StringReader(line));
130.         int token = st.nextToken();
132.         while (token != StreamTokenizer.TT_EOF) {
133.             char command = (char) st.ttype;
134.             switch (command) {
135.                 case '+' -> {
136.                     st.nextToken();
137.                     array.insert(st.sval);
138.                 }
139.                 case '-' -> array.remove();
140.                 case '=' -> {
141.                     st.nextToken();
142.                     array.replace(st.sval);
143.                 }
144.                 case '#' -> array.gotoBeginning();
145.                 case '*' -> array.gotoEnd();
146.                 case '>' -> array.gotoNext();
147.                 case '<' -> array.gotoPrev();
148.                 case '~' -> array.clear();
149.             }
151.             token = st.nextToken();
152.         }
153.     }
155.     private static void executeCommand(DynamicArray<Object> array, String line, PrintWriter writer) throws ListException, IOException {
156.         StreamTokenizer st = new StreamTokenizer(new StringReader(line));
157.         int token = st.nextToken();
159.         while (token != StreamTokenizer.TT_EOF) {
160.             char command = (char) st.ttype;
161.             switch (command) {
162.                 case '+' -> {
163.                     st.nextToken();
164.                     array.insert(st.sval);
165.                 }
166.                 case '-' -> array.remove();
167.                 case '=' -> {
168.                     st.nextToken();
169.                     array.replace(st.sval);
170.                 }
171.                 case '#' -> array.gotoBeginning();
172.                 case '*' -> array.gotoEnd();
173.                 case '>' -> array.gotoNext();
174.                 case '<' -> array.gotoPrev();
175.                 case '~' -> array.clear();
176.             }
178.             token = st.nextToken();
179.         }
180.     }
181. }