中国大学生计算机设计大赛是我国高校面向本科生的计算机应用设计大赛，大赛旨在激发学生学习计算机知识和技能的兴趣与潜能，提高学生运用信息技术解决实际问题的综合能力。通过大赛这种计算机教学实践形式，可展示师生的教与学成果，最终以赛促学，以赛促教，以赛促创。该赛事在历届学生中影响力较大，参与者众多，请结合2021届省赛参赛的数据，借助数据结构课程所学的相关知识，通过对数据的处理和分析，全面了解赛事组织及管理的体系，以及数据结构设计及数据处理在信息管理系统中应用的重要性。赛事相关数据存储在文本文件和excel文件中，相应的文件信息说明如表1所示。其中，各个文件中不同的数据项之间均使用#分隔，图1中给出了文件team.txt中参赛信息的对应数据示例。
从team.txt中读取参赛队伍的基本信息，能够管理各参赛队的基本信息（包含参赛队编号，参赛作品名称，参赛学校，赛事类别，参赛者，指导老师），赛事类别共11项（参见大赛官网jsjds.blcu.edu.cn）；包括增加、删除、修改参赛队伍的信息。`//该程序是对txt文档基本信息的读取以及增删修改
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class TeamManager {
//定义参赛队编号
private String number;
//定义参赛作品名称
private String name;
//定义参赛队所在学校
private String school;
//定义参赛作品类型
private String category;
//参赛者
private String players;
//指导老师
private String coach;
public TeamManager(String number, String name, String school, String category, String players, String coach) {
this.number = number;
this.name = name;
this.school = school;
this.category = category;
this.players = players;
this.coach = coach;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public String getPlayers() {
return players;
}
public void setPlayers(String players) {
this.players = players;
}
public String getCoach() {
return coach;
}
public void setCoach(String coach) {
this.coach = coach;
}
@Override
public String toString() {
return "Team{" +
"number='" + number + '\'' +
", name='" + name + '\'' +
", school='" + school + '\'' +
", category='" + category + '\'' +
", players='" + players + '\'' +
", coach='" + coach + '\'' +
'}';
}
public static void main(String[] args) {
ArrayList<TeamManager> teams = new ArrayList<>();
try {
File file = new File("C:/Users/LENOVO/Documents/Tencent Files/461413102/FileRecv/team.txt");
BufferedReader reader = new BufferedReader(new FileReader(file));
String line = reader.readLine();
while (line != null) {
String[] data = line.split(" ");
TeamManager team = new TeamManager(data[0], data[1], data[2], data[3], data[4], data[5]);
teams.add(team);
line = reader.readLine();
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("请输入您想进行的操作：1-增加参赛队伍信息；2-删除参赛队伍信息；3-修改参赛队伍信息；4-查看所有参赛队伍信息；5-退出");
int choice = Integer.parseInt(scanner.nextLine());
if (choice == 1) {
System.out.println("请输入参赛队伍信息（编号，名称，学校，赛事类别，参赛者，指导老师，用逗号隔开）");
String[] data = scanner.nextLine().split(" ");
TeamManager team = new TeamManager(data[0], data[1], data[2], data[3], data[4], data[5]);
teams.add(team);
System.out.println("参赛队伍信息添加成功");
} else if (choice == 2) {
System.out.println("请输入要删除的参赛队伍编号");
String number = scanner.nextLine();
boolean isRemoved = false;
for (int i = 0; i < teams.size(); i++) {
if (teams.get(i).getNumber().equals(number)) {
teams.remove(i);
isRemoved = true;
break;
}
}
if (isRemoved) {
System.out.println("参赛队伍信息删除成功");
} else {
System.out.println("未找到要删除的参赛队伍信息");
}
} else if (choice == 3) {
System.out.println("请输入要修改的参赛队伍编号");
String number = scanner.nextLine();
boolean isModified = false;
for (int i = 0; i < teams.size(); i++) {
if (teams.get(i).getNumber().equals(number)) {
System.out.println("请输入修改后的参赛队伍信息（编号，名称，学校，赛事类别，参赛者，指导老师，用逗号隔开）");
String[] data = scanner.nextLine().split(" ");
teams.get(i).setNumber(data[0]);
teams.get(i).setName(data[1]);
teams.get(i).setSchool(data[2]);
teams.get(i).setCategory(data[3]);
teams.get(i).setPlayers(data[4]);
teams.get(i).setCoach(data[5]);
isModified = true;
break;
}
}
if (isModified) {
System.out.println("参赛队伍信息修改成功");
} else {
System.out.println("未找到要修改的参赛队伍信息");
}
} else if (choice == 4) {
System.out.println("所有参赛队伍信息如下：");
for (TeamManager team : teams) {
System.out.println(team.toString());
}
} else if (choice == 5) {
System.out.println("退出程序");
break;
} else {
System.out.println("无效操作，请重新输入");
}
}
}
}
`
实现基于二叉排序树的查找。根据提示输入参赛队编号，若查找成功，输出该赛事类别对应的基本信息（参赛作品名称、参赛学校、赛事类别、参赛者和指导老师信息），同时，输出查找成功时的平均查找长度ASL；否则，输出“查找失败！”。请输出ASL的计算表达式和结果值。`import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class TeamManagement {
public static void main(String[] args) {
ArrayList<Team> teams = readTeamsFromFile("C:/Users/LENOVO/Documents/Tencent Files/461413102/FileRecv/team.txt");
if (teams == null) {
System.out.println("读取文件失败");
return;
}
System.out.println("成功读取文件team.txt");
System.out.println("按参赛学校查询");
Scanner scanner = new Scanner(System.in);
int option = scanner.nextInt();
switch(option) {
case 1:
System.out.println("请输入参赛学校名称：");
String name = scanner.next();
ArrayList<Team> result = searchTeamBySchool(name, teams);
if (result.size() > 0) {
System.out.println("查询结果如下：");
for (Team t : result) {
System.out.println(t);
}
} else {
System.out.println("未找到符合条件的参赛团队");
}
break;
default:
System.out.println("无效的选项");
}
}
// 根据参赛学校查询参赛团队
public static ArrayList<Team> searchTeamBySchool(String school, ArrayList<Team> teams) {
ArrayList<Team> result = new ArrayList<>();
for (Team t : teams) {
if (t.getSchool().equals(school)) {
result.add(t);
}
}
Collections.sort(result, new Comparator<Team>() {
@Override
public int compare(Team o1, Team o2) {
return o1.getNumber() - o2.getNumber();
}
});
return result;
}
// 从文件中读取参赛队伍的基本信息
public static ArrayList<Team> readTeamsFromFile(String filename) {
ArrayList<Team> teams = new ArrayList<>();
try {
Scanner scanner = new Scanner(new File(filename));
while (scanner.hasNextLine()) {
String line = scanner.nextLine().trim();
if (line.length() == 0) {
continue;
}
String[] parts = line.split(" ");
if (parts.length != 6) {
System.out.println("无效的数据：" + line);
continue;
}
try {
int number = Integer.parseInt(parts[0].trim());
String name = parts[1].trim();
String school = parts[2].trim();
String category = parts[3].trim();
String participant = parts[4].trim();
String teacher = parts[5].trim();
teams.add(new Team(number, name, school, category, participant, teacher));
} catch (NumberFormatException e) {
System.out.println("无效的数据：" + line);
}
}
scanner.close();
} catch (FileNotFoundException e) {
return null;
}
return teams;
}
}
class Team {
private int number; // 参赛队编号
private String name; // 参赛作品名称
private String school; // 参赛学校
private String category; // 赛事类别
private String participant; // 参赛者
private String teacher; // 指导老师
public Team(int number, String name, String school, String category, String participant, String teacher) {
this.number = number;
this.name = name;
this.school = school;
this.category = category;
this.participant = participant;
this.teacher = teacher;
}
public int getNumber() {
return number;
}
public String getName() {
return name;
}
public String getSchool() {
return school;
}
public String getCategory() {
return category;
}
public String getParticipant() {
return participant;
}
public String getTeacher() {
return teacher;
}
@Override
public String toString() {
return String.format("%d,%s,%s,%s,%s,%s", number, name, school, category, participant, teacher);
}
}
import java.io.*;
class TreeNode {
String key;
String value;
TreeNode left;
TreeNode right;
public TreeNode(String key, String value) {
this.key = key;
this.value = value;
this.left = null;
this.right = null;
}
}
class BinarySearchTree {
TreeNode root;
public BinarySearchTree() {
this.root = null;
}
// 插入节点
public void insert(String key, String value) {
TreeNode node = new TreeNode(key, value);
if (root == null) {
root = node;
} else {
insertRecursive(root, node);
}
}
// 递归插入节点
private void insertRecursive(TreeNode current, TreeNode node) {
if (node.key.compareTo(current.key) < 0) {
if (current.left == null) {
current.left = node;
} else {
insertRecursive(current.left, node);
}
} else if (node.key.compareTo(current.key) > 0) {
if (current.right == null) {
current.right = node;
} else {
insertRecursive(current.right, node);
}
}
}
// 查找节点
public String find(String key) {
if (root == null) {
return null;
}
TreeNode current = root;
while (current != null) {
if (current.key.equals(key)) {
return current.value;
} else if (key.compareTo(current.key) < 0) {
current = current.left;
} else {
current = current.right;
}
}
return null;
}
// 计算平均查找长度
public double calculateASL() {
int totalDepth = calculateDepth(root, 0);
int n = countNodes(root);
return (double) totalDepth / n ;
}
// 计算节点数
private int countNodes(TreeNode node) {
if (node == null) {
return 0;
}
int leftCount = countNodes(node.left);
int rightCount = countNodes(node.right);
return leftCount + rightCount + 1;
}
// 计算深度
private int calculateDepth(TreeNode node, int depth) {
if (node == null) {
return 0;
}
int leftDepth = calculateDepth(node.left, depth + 1);
int rightDepth = calculateDepth(node.right, depth + 1);
return leftDepth + rightDepth + depth;
}
}
class Main {
public static void main(String[] args) throws FileNotFoundException {
BinarySearchTree bst = new BinarySearchTree();
File file = new File(“C:\Users\LENOVO\Documents\Tencent Files\461413102\FileRecv\team.txt”);
BufferedReader br = new BufferedReader(new FileReader(file));
String line;
try {
while ((line = br.readLine()) != null) {
String[] fields = line.split(" ");
String key = fields[0];
String value = fields[1] + “,” + fields[2] + “,” + fields[3] + “,” + fields[4] + “,” + fields[5];
bst.insert(key, value);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("请输入参赛队编号：");
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
try {
String input = stdin.readLine();
String result = bst.find(input);
if (result == null) {
System.out.println("查找失败！");
} else {
String[] fields = result.split(",");
System.out.println("参赛作品名称：" + fields[0]);
System.out.println("参赛学校：" + fields[1]);
System.out.println("赛事类别：" + fields[2]);
System.out.println("参赛者：" + fields[3]);
System.out.println("指导老师：" + fields[4]);
double asl = bst.calculateASL();
System.out.println("平均查找长度ASL的计算表达式：(总查找长度 / 节点数)+1 ");
System.out.println("ASL的计算结果：" + asl);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
能够提供按参赛学校查询参赛团队，根据提示输入参赛学校名称，若查找成功，输出该学校参赛的所有团队的基本信息，输出的参赛团队需有序输出（按参赛队编号）。（排序算法可从选择排序、插入排序、希尔排序、归并排序、堆排序中任意选择，并为选择算法的原因做出说明。）`import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class TeamManagement {
public static void main(String[] args) {
ArrayList<Team> teams = readTeamsFromFile("C:/Users/LENOVO/Documents/Tencent Files/461413102/FileRecv/team.txt");
if (teams == null) {
System.out.println("读取文件失败");
return;
}
System.out.println("成功读取文件team.txt");
System.out.println("按参赛学校查询");
Scanner scanner = new Scanner(System.in);
int option = scanner.nextInt();
switch(option) {
case 1:
System.out.println("请输入参赛学校名称：");
String name = scanner.next();
ArrayList<Team> result = searchTeamBySchool(name, teams);
if (result.size() > 0) {
System.out.println("查询结果如下：");
for (Team t : result) {
System.out.println(t);
}
} else {
System.out.println("未找到符合条件的参赛团队");
}
break;
default:
System.out.println("无效的选项");
}
}
// 根据参赛学校查询参赛团队
public static ArrayList<Team> searchTeamBySchool(String school, ArrayList<Team> teams) {
ArrayList<Team> result = new ArrayList<>();
for (Team t : teams) {
if (t.getSchool().equals(school)) {
result.add(t);
}
}
Collections.sort(result, new Comparator<Team>() {
@Override
public int compare(Team o1, Team o2) {
return o1.getNumber() - o2.getNumber();
}
});
return result;
}
// 从文件中读取参赛队伍的基本信息
public static ArrayList<Team> readTeamsFromFile(String filename) {
ArrayList<Team> teams = new ArrayList<>();
try {
Scanner scanner = new Scanner(new File(filename));
while (scanner.hasNextLine()) {
String line = scanner.nextLine().trim();
if (line.length() == 0) {
continue;
}
String[] parts = line.split(" ");
if (parts.length != 6) {
System.out.println("无效的数据：" + line);
continue;
}
try {
int number = Integer.parseInt(parts[0].trim());
String name = parts[1].trim();
String school = parts[2].trim();
String category = parts[3].trim();
String participant = parts[4].trim();
String teacher = parts[5].trim();
teams.add(new Team(number, name, school, category, participant, teacher));
} catch (NumberFormatException e) {
System.out.println("无效的数据：" + line);
}
}
scanner.close();
} catch (FileNotFoundException e) {
return null;
}
return teams;
}
}
class Team {
private int number; // 参赛队编号
private String name; // 参赛作品名称
private String school; // 参赛学校
private String category; // 赛事类别
private String participant; // 参赛者
private String teacher; // 指导老师
public Team(int number, String name, String school, String category, String participant, String teacher) {
this.number = number;
this.name = name;
this.school = school;
this.category = category;
this.participant = participant;
this.teacher = teacher;
}
public int getNumber() {
return number;
}
public String getName() {
return name;
}
public String getSchool() {
return school;
}
public String getCategory() {
return category;
}
public String getParticipant() {
return participant;
}
public String getTeacher() {
return teacher;
}
@Override
public String toString() {
return String.format("%d,%s,%s,%s,%s,%s", number, name, school, category, participant, teacher);
}
}
为省赛现场设计一个决赛叫号系统。所有参赛队按赛事组织文件中的赛事类别分到9个决赛室，决赛室按顺序叫号，被叫号参赛队进场，比赛结束后，下一参赛队才能进赛场。请模拟决赛叫号系统，演示省赛现场各决赛室的参赛队进场情况。（模拟时，各参赛队进场比赛时间可设为0.5秒）
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class Championship {
private static final int NUM_COMPETITIONS = 9;
private static final int NUM_FINAL_ROOMS = 9;
private static final long ENTRY_INTERVAL = 500; // 进入时间间隔，单位毫秒
private final List competitionCategories;
private final List teamList;
private final List[] finalRooms;
public Championship(String fileName) {
competitionCategories = new ArrayList<>();
teamList = new ArrayList<>();
finalRooms = new List[NUM_FINAL_ROOMS];
for (int i = 0; i < NUM_FINAL_ROOMS; i++) {
finalRooms[i] = new ArrayList<>();
}
readTeamsFromFile(fileName);
}
public void start() {
for (int i = 0; i < NUM_COMPETITIONS; i++) {
finalRooms[i % NUM_FINAL_ROOMS].addAll(getTeamsWithCategory(competitionCategories.get(i)));
}
for (int i = 0; i < NUM_FINAL_ROOMS; i++) {
System.out.println("Final room " + i + ":");
for (Object team : finalRooms[i]) {
try {
System.out.println("Please enter the competition arena: " + team);
Thread.sleep(ENTRY_INTERVAL);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
}
private void readTeamsFromFile(String fileName) {
try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
String line;
while ((line = br.readLine()) != null) {
teamList.add(line);
String[] categories = line.split(" ");
for (int i = 1; i < categories.length; i++) {
String category = categories[i].trim();
if (!competitionCategories.contains(category)) {
competitionCategories.add(category);
}
}
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
private List<String> getTeamsWithCategory(String category) {
List<String> teams = new ArrayList<>();
for (String team : teamList) {
String[] categories = team.split(" ");
for (int i = 1; i < categories.length; i++) {
if (categories[i].trim().equals(category)) {
teams.add(categories[0]);
break;
}
}
}
return teams;
}
public static void main(String[] args) {
String fileName = “C:/Users/LENOVO/Documents/Tencent Files/461413102/FileRecv/team.txt”;
Championship championship = new Championship(fileName);
championship.start();
}
}
赛事系统为参赛者提供赛地的校园导游程序。为参赛者提供各种路径导航的查询服务。以我校长山校区提供比赛场地为例，（请为参赛者提供不少于10个目标地的导航。可为参赛者提供校园地图中任意目标地（建筑物）相关信息的查询；提供图中任意目标地（建筑物）的问路查询，即查询任意两个目的地（建筑物）之间的一条最短的简单路径。`//校园地图导游系统
import java.util.*;
public class CampusGuide {
//建筑物
private Map<String, Building> buildings;
//方向
private Map<String, List> connections;
public CampusGuide() {
buildings = new HashMap<>();
connections = new HashMap<>();
initializeBuildings();
initializeConnections();
}
private void initializeBuildings() {
// 初始化所有建筑物
buildings.put("A", new Building("A", "三号组团"));
buildings.put("B", new Building("B", "西苑食堂"));
buildings.put("C", new Building("C", "明德园"));
buildings.put("D", new Building("D", "文体中心"));
buildings.put("E", new Building("E", "操场"));
buildings.put("F", new Building("F", "文理大楼"));
buildings.put("G", new Building("G", "海韵湖"));
buildings.put("H", new Building("H", "求索园"));
buildings.put("I", new Building("I", "东苑食堂"));
buildings.put("J", new Building("J", "图书馆"));
}
private void initializeConnections() {
// 初始化所有建筑物之间的连接
addConnection("A", "B", 100);
addConnection("A", "D", 200);
addConnection("B", "D", 150);
addConnection("B", "C", 80);
addConnection("C", "E", 120);
addConnection("D", "E", 50);
addConnection("C", "F", 110);
addConnection("F", "H", 60);
addConnection("E", "H", 150);
addConnection("F", "G", 80);
addConnection("G", "J", 100);
addConnection("H", "J", 70);
addConnection("H", "I", 90);
addConnection("J", "I", 50);
addConnection("E", "I", 230);
}
private void addConnection(String start, String end, int distance) {
// 添加连接
Connection connection = new Connection(getBuilding(start), getBuilding(end), distance);
if (connections.containsKey(start)) {
connections.get(start).add(connection);
} else {
List<Connection> list = new ArrayList<>();
list.add(connection);
connections.put(start, list);
}
if (connections.containsKey(end)) {
connections.get(end).add(connection);
} else {
List<Connection> list = new ArrayList<>();
list.add(connection);
connections.put(end, list);
}
}
private Building getBuilding(String id) {
// 根据ID获取建筑物
return buildings.get(id);
}
private List<Connection> getConnections(String id) {
// 根据ID获取连接
return connections.get(id);
}
private void printPath(List<Building> path) {
// 打印路径
System.out.print("Path: ");
for (int i = 0; i < path.size(); i++) {
System.out.print(path.get(i).getName());
if (i < path.size()-1 ) {
System.out.print(" -> ");
}
}
System.out.println();
}
public void navigate(String start, String end) {
// 导航功能
Building startBuilding = getBuilding(start);
Building endBuilding = getBuilding(end);
Map<Building, Building> previous = new HashMap<>();
Map<Building, Integer> distances = new HashMap<>();
Set<Building> visited = new HashSet<>();
PriorityQueue<Building> queue = new PriorityQueue<>(Comparator.comparingInt(distances::get));
distances.put(startBuilding, 0);
queue.offer(startBuilding);
while (!queue.isEmpty()) {
Building current = queue.poll();
if (current.equals(endBuilding)) {
List<Building> path = new ArrayList<>();
path.add(current);
while (previous.containsKey(current)) {
current = previous.get(current);
path.add(0, current);
}
System.out.println("Distance: " + distances.get(endBuilding));
printPath(path);
return;
}
if (visited.contains(current)) {
continue;
}
visited.add(current);
List<Connection> currentConnections = getConnections(current.getId());
for (Connection connection : currentConnections) {
Building neighbor = connection.getOtherBuilding(current);
int distanceFromStart = distances.get(current) + connection.getDistance();
if (distances.containsKey(neighbor) && distances.get(neighbor) <= distanceFromStart) {
continue;
}
previous.put(neighbor, current);
distances.put(neighbor, distanceFromStart);
queue.offer(neighbor);
}
}
System.out.println("No path found");
}
public void getBuildingInfo(String id) {
// 获取建筑物信息
Building building = getBuilding(id);
System.out.println("Building " + building.getName() + ", ID: " + building.getId());
}
public void findShortestPath(String start, String end) {
// 查找最短路径
Building startBuilding = getBuilding(start);
Building endBuilding = getBuilding(end);
navigate(start, end);
}
}
public class CampusGuideTest {
public static void main(String[] args) {
CampusGuide guide = new CampusGuide();
guide.getBuildingInfo("A");
guide.findShortestPath("A", "G");
}
}
```
9万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
