数据结构-实验一 线性表实验

1、实验目的

1. 线性表的逻辑结构特点和线性表抽象数据类型的描述方法
2. 线性表的存储结构设计方法以及优缺点
3. 掌握线性表的基本知识
4. 深入理解、掌握并灵活运用线性表。
5. 熟练掌握线性表的存储结构及主要运算的实现
6. 掌握栈的定义、栈的逻辑结构特性和栈的基本运算。
7. 理解栈在表达式求值中的应用。
8. 掌握队列的定义、队列的逻辑结构特性和栈的基本运算。
9. 理解队列的应用。

2、实验内容

题目1：Josephus环的问题及算法

【实验内容】

古代某法官要判决n个犯人的死刑，他有一条荒唐的法律，将犯人站成一个圆圈，从第start个犯人开始数起，每数到第distance的犯人，就出列处决；再从下一个犯人开始计数，数到的犯人被处决……以此类推不断循环，直到剩下最后一个犯人予以赦免。此为Josephus环问题。

要求：采用线性表（可以为顺序表或链表）标记n个人，这n个人分别标为A、B、C……,请用Java语言编写程序，按顺序输出出列人的标记。

输入格式:

输入为3个正整数，分别表示n、start、distance，均不超过1000

输出格式:

输出为一行整数，为出列人的编号。每个整数后一个空格。

【实验要求】

单链表

题目2：

【实验内容】

设某银行有A、B两个业务窗口，且处理业务的速度不一样，其中A窗口处理速度是B窗口的2倍 —— 即当A窗口每处理完2个顾客时，B窗口处理完1个顾客。给定到达银行的顾客序列，请按业务完成的顺序输出顾客序列。假定不考虑顾客先后到达的时间间隔，并且当不同窗口同时处理完2个顾客时，A窗口顾客优先输出。

输入格式:

输入为一行正整数，其中第1个数字N(≤1000)为顾客总数，后面跟着N位顾客的编号。编号为奇数的顾客需要到A窗口办理业务，为偶数的顾客则去B窗口。数字间以空格分隔。

输出格式:

按业务处理完成的顺序输出顾客的编号。数字间以空格分隔，但最后一个编号后不能有多余的空格。

输入样例:

8 2 1 3 9 4 11 13 15

输出样例:

1 3 2 9 11 4 13 15

【实验要求】

队列

3、实验环境

（【硬件环境要求】

笔记本

【使用的软件名称、版本号】

比如Windows环境下JDK8、eclipse

4、实验过程

每道题目都要写出以下步骤：

1. 请写出解题的思路（采用文字、流程图或伪代码说明），每道题必须至少有一张图，可以是手绘，电脑制作等；内容可以是这题的思路，或者某种算法的演示；

1、题目一：

1. 先定义了一个名为Node的类
2. 
3. 代码先以截图形式粘贴（有高亮），然后再把代码文本复制上来；

代码文本：

1. package demo02;
3. import java.util.Scanner;  
5. class Node {  
6.     char label;  
7.     Node next;  
8.   
9.     Node(char label) {  
10.         this.label = label;  
11.         this.next = null;  
12.     }  
13. }  
14.   
15. public class JosephusProblem {  
16.     public static void main(String[] args) {  
17.         Scanner scanner = new Scanner(System.in);  
18.         System.out.println("请输入犯人的数量n，起始位置start，以及计数的间隔distance:");  
19.         int n = scanner.nextInt();  
20.         int start = scanner.nextInt(); 
21.         int distance = scanner.nextInt();  
22.   
23.         // 创建链表  
24.         Node head = null;  
25.         Node prev = null;  
26.         for (char c = 'A'; c <= 'A' + n - 1; c++) {  
27.             Node newNode = new Node(c);  
28.             if (head == null) {  
29.                 head = newNode;  
30.             } else {  
31.                 prev.next = newNode;  
32.             }  
33.             prev = newNode;  
34.         }  
35.         prev.next = head; // 构成循环链表  
36.   
37.         // 初始化当前节点为起始节点的前一个节点  
38.         Node current = head;  
39.         for (int i = 0; i < start; i++) {  
40.             current = current.next;  
41.         }  
42.   
43.         // 开始解决Josephus问题  
44.         Node prevKilled = null;  
45.         while (current.next != current) { // 当链表中剩下最后一个节点时停止  
46.             // 计数到distance的节点  
47.             for (int i = 0; i < distance - 1; i++) {  
48.                 prevKilled = current;  
49.                 current = current.next;  
50.             }  
51.             // 输出出列的节点  
52.             System.out.print(current.label + " ");  
53.             // 从链表中移除出列的节点  
54.             prevKilled.next = current.next;  
55.             current = prevKilled.next;  
56.         }  
57.         // 输出最后一个被赦免的节点  
58.         System.out.println(current.label);  
59.   
60.         scanner.close();  
61.     }  
62. }

如果PTA平台使用，粘贴代码运行结果；如果不使用，则需要记录你的测试数据和对应结果（一般3组起步）

2、题目二：

1. 过程图：

2）代码文本：

1. import java.util.ArrayDeque;
2. import java.util.Scanner;
3. public class Main {
4.     public static void main(String[] args) {
5.         Scanner sc = new Scanner(System.in);
6.         int n = sc.nextInt();
7.         Integer[] array = new Integer[n];
8.         // 创建一个Integer类型的数组，长度为n，用于存储用户输入的整数
9.         String str = new String();
10.         // 创建一个空的字符串，用于存储按照特定规则拼接后的结果
11.         for (int i = 0; i<n;i++) // 循环n次，用于读取用户输入的n个整数
12.             array[i] = sc.nextInt(); // 读取一个整数并存储到数组array的对应位置
13.         ArrayDeque arrayDeque1 = new ArrayDeque();
14.         // 创建一个新的ArrayDeque对象，用于存储奇数
15.         ArrayDeque arrayDeque2 = new ArrayDeque();
16.         // 创建另一个新的ArrayDeque对象，用于存储偶数
17.         for(int i = 0;i<array.length;i++){ // 遍历数组array中的每一个元素
18.             if (array[i]%2!=0) { // 如果当前元素是奇数（除以2的余数不为0）
19.                 arrayDeque1.addLast(array[i]); // 将这个奇数添加到arrayDeque1的末尾
20.             }else {
21.                 arrayDeque2.addLast(array[i]); // 将这个偶数添加到arrayDeque2的末尾
22.             }
23.         }
24.         while(!arrayDeque1.isEmpty() && !arrayDeque2.isEmpty()){ // 当DequeA和DequeB不为空时
25.             if(arrayDeque1.size()%2==0 && arrayDeque1.size()>=2){ // 是否为偶数且至少有两个元素
26.                 str += arrayDeque1.removeFirst()+" ";
27.                 // 从DequeA中取出第一个元素，并拼接到str中，后面加一个空格
28.                 str += arrayDeque1.removeFirst()+" ";
29.                 // 从DequeA中再次取出第一个元素，并拼接到str中，后面加一个空格
30.                 str += arrayDeque2.removeFirst()+" ";
31.                 // 从DequeB中取出第一个元素，并拼接到str中，后面加一个空格
32.             }else{ // 如果进入else则意味着arrayDeque1.size() == 1
33.                 str += arrayDeque1.removeFirst()+" ";
34.                 // 从DequeA中取出第一个元素，并拼接到str中，后面加一个空格
35.                 str += arrayDeque2.removeFirst()+" ";
36.                 // 从DequeB中取出第一个元素，并拼接到str中，后面加一个空格
37.             }
38.         }
39.         if(arrayDeque1.isEmpty()){ //判断是否为空
40.             arrayDeque1 = arrayDeque2; 
41.             //如果为空将arrayDeque2的引用赋值给arrayDeque1
42.         }
43.         if(!arrayDeque1.isEmpty()){ //再次判断是否不为空
44.             while(!arrayDeque1.isEmpty()){
45.                 str += arrayDeque1.removeFirst()+" ";
46.                 // 从队列中取出第一个元素，转换为字符串并添加一个空格，然后将这个字符串添加到str上
47.             }
48.         }
49.         System.out.println(str.substring(0,str.length()-1));
50.         // 每次从队列中取出一个元素并添加到str时都会在其后添加一个空格，
51.         // 所以使用substring方法去除最后一个字符（最后那空格）
52.     }
53. }

3）Pta运行结果：