数据结构_java_实验1指导.pdf

1、实验一 线性表及其应用 一、实验目的 1. 掌握数据结 构中线性表的基本概念。 2. 熟练掌握线 性表的基本操作， 插入、 删除、 查 找， 以及线性表合并等运算在顺序存储 结构和链接存储结构上的实现。 3. 熟练掌握链 表的各种操作和应用。 二、本实验使用的接口 public interface SimpleList /* * 返回此列表中的元素个数。 * return 此列表中的元素个数 */ int size(); /* * 将指定的元素插入到此列表中的指定位置。 * param obj 要插入的元素 * param index 指定元素插入位置的索引 * throws ArrayInd

2、exOutOfBoundsException 如果索引超出范围 */ void insert(Object obj, int index); /* * 删除此列表中指定位置的元素。 * param index 要删除元素的索引 * throws ArrayIndexOutOfBoundsException 如果索引超出范围 */ void delete(int index); /* * 返回列表中指定位置的元素。 * param index 指定的索引 * return 指定索引处的元素 * throws ArrayIndexOutOfBoundsException 如果索引超出范围 */ O

3、bject get(int index); 三、实验内容 1 设计 一个 带头结点 的 循环单链 表 类。 (1) 要求 实现 SimpleList 接口，成 员函数包括取数据元素个数、插入、删除、取数据元素。 设计一个测试主函数，实际运行验证其各成员函数的正确性。 (2) 测试 将 1 ，2 ，3 ，9 ，10 依 次插入链表； 将 0 插入到 索引为 0 的 地方； 将 100 插入 到链表末端； 删除索引为 10 的元素； 根据当前链表元素个数依次取得数据元素并打印。 (3) 算法思想 参见教材第二章。 注意： 每次包含索引操作时检查索引是否合法， 插入、 删除操作时正 确调整 size

4、 大小。 (4) 主要类划分 结点类 Node ，主要成员： private Object data; private Node next; 带头结点的循环单链表类 MyLinkedList1 ，主要 成员： private Node head; private int size; 测试类 TestOfMyLinkedList1 。 辅助输出类 PrintManager 。 2 设计 一个 不带头结 点 的循环单 链 表类。 (1) 要求，参见 1 。 (2) 测试，参见 1 。 (3) 算法思想 参见教材第二章。 注意： 每次包含索引操作时检查索引是否合法， 插入、 删除操作时正 确调整 s

5、ize 大小；要考虑在第一个数据元素结点前插入和删除第一个数据元素结点时，与 其他位置插入和删除其他位置结点时的不同情况。 (4) 主要类划分 结点类 Node 。 不带头结点的循环单链表类 MyLinkedList2 ，主 要成员： private Node head; private int size; 测试类 TestOfMyLinkedList2 。 3 设计 一个 带头结点 的 循环双向 链 表类。 (1) 要求，参见 1 。 (2) 测试，参见 1 。 (3) 算法思想 参见教材第二章。 注意： 每次包含索引操作时检查索引是否合法， 插入、 删除操作时正 确调整 size 大小。

6、(4) 主要类划分 结点类 Node ，主要成员： private Object data; private Node next; private Node prev; 带头结点的循环双向链表类 MyLinkedList3 ，主 要成员： private Node head; private int size; 测试类 TestOfMyLinkedList3 。 4 约 瑟夫环 问题仿真 ： 设编号为 1,2, ,n(n0) 个人按顺时 针 方向围坐 一 圈， 每 人持 有一个 正整数密 码 。先随机 给 出一个报 数 值 m， 然后 从第一个 人 开始，顺 时 针方向 自 1 起顺序 报 数

7、，报到 m 时 停 止 报数， 报 m 的人出 列 ， 将他的 密 码 作为新 的 m 值，从 他 在 顺时针 方 向 上的下一 个 开始自 1 起 顺序报数 ； 如此下去 ， 直到所有 的 人全部出 列 为止。 (1) 要求： 设计一个程序模拟此过程，给出出列人的编号序列。 (2) 测试： n = 7 ，7 个人 的密码依次为 3 ，1 ，7 ，2 ，4 ，8 ，4 。 初始密码 m = 20 。 (3) 算法思想 利用不带头结点的 n 个 结点的双向循环链表实现此模拟。 （ 参见类划分） 从第一个结点开始， 从 1 到 m （currentPass ） 循环计数， 数到 m 时， 输出 该

8、结点 （node ） 的编号（node.id ） ，再把 该结点的密码值作为新的当前密码值 m （currentPass = node.pass ） ， 最后删除该结点。随后，从该结点的下一个结点开始自 1 到 m 循环计 数，直到所有结 点全部删除为止。 (4) 主要类划分 结点类 Person ，主要成员 ： private int id; private int password; private Person next; private Person prev; 约瑟夫环仿真类 CycleGame ，主要成 员： private int size; private Person hea

9、d; private int password; public CycleGame(int initialPassword);/ 用指定的初始密码构造一个新游戏 private void checkPassword(int i);/ 检查 密码的合法性 private Person getPerson(int index);/ 获取 指定所引处的人员 public synchronized void addPerson(int password);/ 为游戏增加一个人员 private void delete(Person person);/ 获取 指定人员 public synchroniz

10、ed void play();/ 进行游戏 测试类 TestOfCycleGame 。 四、参考实现 1 接 口 SimpleList ： 1: package chapter2; 2: /* 3: * SimpleList 接口的用户 可以根据元素的整数索引 （在列表中的位置） 访 问元素、 删除元素， 也可以对列表中每个元素的插入位置进行精确地控制。 4: */ 5: public interface SimpleList 6: /* 7: * 返回列表 中指定位置的元素。 8: * param index 9: * 指定的索 引 10: * return 指定索引处的元素 11: * t

11、hrows ArrayIndexOutOfBoundsException 12: * 如果索 引超出范围 13: */ 14: T get(int index); 15: /* 16: * 将指定元 素添加到此列表的末尾。 17: * param element 18: * 要添加的 元素 19: */ 20: void append(T element); 21: /* 22: * 将指定的 元素插入到此列表中的指定位置。 23: * param element 24: * 要插入的 元素 25: * param index 26: * 指定元素 插入位置的索引 27: * throws A

12、rrayIndexOutOfBoundsException 28: * 如果索 引超出范围 29: */ 30: void insert(T element, int index); 31: /* 32: * 删除此列 表中指定位置的元素。 33: * param index 34: * 要删除元 素的索引 35: * throws ArrayIndexOutOfBoundsException 36: * 如果索 引超出范围 37: */ 38: void delete(int index); 39: /* 40: * 返回此列 表中的元素个数。 41: * return 此列表中的元素个数

13、42: */ 43: int size(); 44: 2 带头 结点 的循环单 链 表类 MyLinkedList1 ： 1: package chapter2; 2: /* 3: * MyLinkedList1 是带头 结点的循环单向链表类。 备注 ： 此类是线程 安全的。 4: */ 5: public class MyLinkedList1 implements SimpleList 6: private int size = 0; 7: private Node head; 8: /* 9: * 构造一个 新的 link MyLinkedList1 。 10: */ 11: publi

14、c MyLinkedList1() 12: head = new Node(null, head); 13: 14: /* 15: * 检查指定 的索引是否超出范围。 16: * param index 17: * 指定的索 引 18: */ 19: protected void checkRange(int index) 20: if (index = size) 21: throw new ArrayIndexOutOfBoundsException(index); 22: 23: /* 24: * 返回指定 索引位置的结点。 25: * param index 26: * 指定的索 引

15、27: * return 指定索引位置的结点 28: */ 29: protected Node getNode(int index) 30: Node node = head; 31: for (int i = -1; i index; i+) 32: node = node.next; 33: return node; 34: 35: Override 36: public synchronized void append(E element) 37: getNode(size - 1).next = new Node(element, head); 38: size+; 39: 40:

16、Override 41: public synchronized void delete(int index) 42: checkRange(index); 43: getNode(index - 1).next = getNode(index).next; 44: size-; 45: 46: Override 47: public synchronized E get(int index) 48: checkRange(index); 49: return getNode(index).data; 50: 51: Override 52: public synchronized void

17、insert(E element, int index) 53: checkRange(index); 54: Node preNode = getNode(index - 1); 55: preNode.next = new Node(element, preNode.next); 56: size+; 57: 58: Override 59: public int size() 60: return size; 61: 62: /* 63: * Node 类 用来表示 link MyLinkedList1 的 结点。 64: */ 65: protected static class No

18、de 66: public E data; 67: public Node next; 68: public Node(E data, Node next) 69: this.data = data; 70: this.next = next; 71: 72: 73: 辅助输出 类 PrintManager ： 1: package chapter2.test; 2: import chapter2.SimpleList; 3: public class PrintManager 4: public static void printAllElements(SimpleList simpleL

19、ist) 5: synchronized (simpleList) 6: for (int i = 0; i linkedList; 6: linkedList = new MyLinkedList1(); 7: for (int i = 0; i 备 注： 此类是线 程安全的。 4: */ 5: public class MyLinkedList2 implements SimpleList 6: private int size = 0; 7: private Node head; 8: /* 9: * 构造一个 新的 link MyLinkedList2 。 10: */ 11: pub

20、lic MyLinkedList2() 12: head = null; 13: 14: /* 15: * 检查指定 的索引是否超出范围。 16: * param index 17: * 指定的索 引 18: */ 19: private void checkRange(int index) 20: if (index = size) 21: throw new ArrayIndexOutOfBoundsException(index); 22: 23: /* 24: * 返回指定 索引位置的结点。 25: * param index 26: * 指定的索 引 27: * return 指定索

21、引位置的结点 28: */ 29: private Node getNode(int index) 30: checkRange(index); 31: Node node = head; 32: for (int i = 0; i node = new Node(element, head); 39: if (size = 0) 40: head = node; 41: e l s e 42: getNode(size - 1).next = node; 43: size+; 44: 45: Override 46: public synchronized void delete(int i

22、ndex) 47: Node node = getNode(index); 48: if (index = 0) 49: head = node.next; 50: e l s e 51: getNode(index - 1).next = node.next; 52: size-; 53: 54: Override 55: public synchronized E get(int index) 56: return getNode(index).data; 57: 58: Override 59: public synchronized void insert(E element, int

23、 index) 60: Node node = getNode(index); 61: Node node2 = new Node(element, node); 62: if (index = 0) 63: head = node2; 64: e l s e 65: getNode(index - 1).next = node2; 66: size+; 67: 68: Override 69: public int size() 70: return size; 71: 72: /* 73: * Node 类 用来表示 link MyLinkedList2 的 结点。 74: */ 75:

24、private static class Node 76: public E data; 77: public Node next; 78: public Node(E data, Node next) 79: this.data = data; 80: this.next = next; 81: 82: 83: 4 带头 结点 的循环双 向 链表类 MyLinkedList3 ，其余参考 2 中的实现 ： 1: package chapter2; 2: /* 3: * MyLinkedList3 是带头 结点的循环双向链表类。 备注 ： 此类是线程 安全的。 4: */ 5: public

25、class MyLinkedList3 implements SimpleList 6: private int size = 0; 7: private Node head; 8: /* 9: * 构造一个 新的 link MyLinkedList3 。 10: */ 11: public MyLinkedList3() 12: head = new Node(null, head, head); 13: 14: /* 15: * 检查指定 的索引是否超出范围。 16: * param index 17: * 指定的索 引 18: */ 19: private void checkRange

26、(int index) 20: if (index = size) 21: throw new ArrayIndexOutOfBoundsException(index); 22: 23: /* 24: * 返回指定 索引位置的结点。 25: * param index 26: * 指定的索 引 27: * return 指定索引位置的结点 28: */ 29: private Node getNode(int index) 30: Node node = head; 31: for (int i = -1; i node = getNode(size - 1); 38: Node newNo

27、de = new Node(element, head, node); 39: node.next = newNode; 40: head.prev = newNode; 41: size+; 42: 43: Override 44: public synchronized void delete(int index) 45: checkRange(index); 46: Node node = getNode(index); 47: node.prev.next = node.next; 48: node.next.prev = node.prev; 49: size-; 50: 51: O

28、verride 52: public synchronized E get(int index) 53: checkRange(index); 54: return getNode(index).data; 55: 56: Override 57: public synchronized void insert(E element, int index) 58: checkRange(index); 59: Node node = getNode(index); 60: Node newNode = new Node(element, node, node.prev); 61: node.pr

29、ev.next = newNode; 62: size+; 63: 64: Override 65: public int size() 66: return size; 67: 68: /* 69: * Node 类 用来表示 link MyLinkedList3 的 结点。 70: */ 71: private static class Node 72: private E data; 73: private Node next; 74: private Node prev; 75: public Node(E data, Node next, Node prev) 76: this.da

30、ta = data; 77: this.next = next; 78: this.prev = prev; 79: 80: 81: 4 约瑟 夫环 问题仿真 类 CycleGame ： 1: package chapter2; 2: /* 3: * 无头结点 的循环双向链表实现的约瑟夫环仿真类。 4: */ 5: public class CycleGame 6: private int size = 0; 7: private Person head = null; 8: private int password = 0; 9: /* 10: * 用指定的 初始密码构造一个新的游戏。 11

31、: * param initialPassword 12: * 游戏初始 密码 13: */ 14: public CycleGame(int initialPassword) 15: checkPassword(initialPassword); 16: password = initialPassword; 17: 18: private void checkPassword(int i) 19: i f ( i 0) 58: Person person = head; 59: for (int i = 1; size 1; i+) 60: System.out.print(new Str

32、ingBuilder().append(person.id). append(“ 号报数为：“).append(i).append(“, “).toString(); 61: if (i = password) 62: i = 0 ; 63: password = person.password; 64: d e l e t e ( p e r s o n ) ; 65: S y s t e m . o u t . p r i n t ( “ ( 密码更换为：“ + password + “)n“); 66: 67: person = person.next; 68: 69: delete(p

33、erson); 70: 71: 72: private static class Person 73: private int id; 74: private int password; 75: private Person next; 76: pr iv ate P er s o n pr e v; 77: public Person(int id, int pass, Person next, Person prev) 78: this.id = id; 79: password = pass; 80: this.next = next; 81: this.prev = prev; 82:

34、 83: 84: 测试类 TestOfCycleGame ： 1: package chapter2.test; 2: import chapter2.CycleGame; 3: public class TestOfCycleGame 4: public static void main(String args) 5: int pass = 3, 1, 7, 2, 4, 8, 4 ; 6: CycleGame game = new CycleGame(20); 7: for (int i = 0; i pass.length; i+) 8: game.addPerson(passi); 9: game.play(); 10: 11: