数据结构课设完整代码

Team类

 

package ComputerSystem;

public class Team {
    //id name school type member teacher
    private String id;//参队伍编号
    private String name;//参赛队伍作品名
    private String school;//参赛队伍所属学校
    private String type;//参赛队伍作品类别
    private String member;//参赛队伍成员
    private String teacher;//参赛队伍指导老师
    public Team(){
    }
    public Team(String id,String name,String school,String type,String member,String teacher){
        this.id=id;
        this.name=name;
        this.school=school;
        this.type=type;
        this.member=member;
        this.teacher=teacher;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMember() {
        return member;
    }

    public void setMember(String member) {
        this.member = member;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getTeacher() {
        return teacher;
    }

    public void setTeacher(String teacher) {
        this.teacher = teacher;
    }
}

ComputerSystem类

package ComputerSystem;
import java.util.ArrayList;
import java.util.Scanner;
import java.io.*;
import java.io.BufferedReader;
import java.io.FileReader;

public class ComputerSystem {
    /*把文本文件中的数据读取集合中，并遍历集合。文件中每一行数据是一个集合元素

         1：创建 ArrayList 集合对象
         2：创建字符缓冲输入流对象
         3：调用字符缓冲输入流对象的方法读数据
         4：把读取到的字符串数据存储到集合中
         5：释放资源
         6：遍历集合
         */
    static ArrayList<Team> list = new ArrayList<Team>();

    public static void main(String[] args) throws IOException {
//        BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\lenovo\\IdeaProjects\\ComputerSystem\\team.txt"));
        BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\lenovo\\IdeaProjects\\ComputerSystem\\team.txt"));
        br.readLine();// 跳过文件第一行标题行
        //创建 ArrayList 集合对象
        ArrayList<Team> list = new ArrayList<Team>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null) {
            //把读取到的字符串数据存储到集合中
            String[] strList = line.split("#");
            Team t = new Team();
            t.setId(strList[0].trim());
            t.setName(strList[1].trim());
            t.setSchool(strList[2].trim());
            t.setType(strList[3].trim());
            t.setMember(strList[4].trim());
            t.setTeacher(strList[5].trim());//通过索引访问每个字段，并使用trim()方法去除前后空格。将其存储到Team对象中
            list.add(t);
        }

        //释放资源
        //br.close();
        loop:
        while (true) {
            System.out.println("---------------欢迎来到计算机设计大赛管理系统 --------------");
            System.out.println("1：添加队伍");
            System.out.println("2：删除队伍");
            System.out.println("3：修改队伍");
            System.out.println("4：查询某学校参赛队伍");
            System.out.println("5：查询所有参赛队伍");
            System.out.println("6：BST查找");
            System.out.println("7：叫号系统");
            System.out.println("8：退出系统");
            System.out.println("---------------请输入您的选择--------------");
            Scanner sc = new Scanner(System.in);
            String choose = sc.next();//next比nextin容错率更高
            switch (choose) {
                case "1" -> addTeam(list);
                case "2" -> deleteTeam(list);
                case "3" -> updateTeam(list);
                case "4" -> queryTeam(list);
                case "5" -> queryall(list);
                case "6" -> bstSearch(list);
                case "7" -> call(list);
                case "8" -> {
                    System.out.println("退出系统");
                    break loop;//否则只会跳出switch或者使用停止虚拟机运行System.exit(status:0);
                }
                default -> System.out.println("没有这个选项！");
            }

        }
    }


    //添加队伍
    public static void addTeam(ArrayList<Team> list) {
        //利用空参构造先创建队伍对象
        Team t = new Team();
        Scanner sc = new Scanner(System.in);
        String id = null;
        while (true) {
            System.out.println("请添加参赛队编号");
            id = sc.next();
            boolean flag = contains(list, id);
            if (flag) {
                //表示id已经存在需要重新录入
                System.out.println("此id已经存在，请重新录入");
            } else {
                //表示id不存在，可以录入
                t.setId(id);
                break;
            }
        }
        t.setId(id);

        System.out.println("请添加参赛作品名");
        String name = sc.next();
        t.setName(name);

        System.out.println("请添加参赛学校");
        String school = sc.next();
        t.setSchool(school);

        System.out.println("请添加赛事类别");
        String type = sc.next();
        t.setType(type);

        System.out.println("请添加参赛者");
        String member = sc.next();
        t.setMember(member);

        System.out.println("请添加指导老师");
        String teacher = sc.next();
        t.setTeacher(teacher);
        //把学生对象添加至集合中
        list.add(t);
        //提示
        System.out.println("队伍信息添加成功");
    }

    //删除队伍
    public static void deleteTeam(ArrayList<Team> list) {
        System.out.println("删除队伍");
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入需要删除的队伍编号");
        String id = sc.next();
        //查询id 在集合中的索引
        int index = getIndex1(list, id);
        //对index进行判断
        //若大于等于0则表示存在，直接删除
        //如果是-1，不存在，结束方法回到菜单
        if (index >= 0) {
            //若大于等于0则表示存在，直接删除
            list.remove(index);
            System.out.println("参赛编号为" + id + "的参赛队伍删除成功");
        } else {
            System.out.println("编号不存在，删除失败！");
        }

    }

    //修改队伍
    public static void updateTeam(ArrayList<Team> list) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入需要修该的队伍的编号");
        String id = sc.next();
        int index = getIndex1(list, id);
        if (index == -1) {
            System.out.println("要修改的队伍编号" + id + "不存在，请重新输入");
            return;
        }
        //当代码执行到这里，表示当前id存在
        //获取需要修改对象
        Team tem = list.get(index);
        //输入其它信息并修改
        System.out.println("请输入要修改的参赛作品名");
        String newName = sc.next();
        tem.setName(newName);

        System.out.println("请输入要修改的参赛学校");
        String newSchool = sc.next();
        tem.setSchool(newSchool);

        System.out.println("请输入要修改的赛事类别");
        String newType = sc.next();
        tem.setType(newType);

        System.out.println("请输入要修改的参赛者");
        String newMember = sc.next();
        tem.setMember(newMember);

        System.out.println("请输入要修改的指导老师");
        String newTeacher = sc.next();
        tem.setTeacher(newTeacher);

        System.out.println("该参赛队伍信息已修改完成！");
    }

    //查询某学校参赛队伍
    public static void queryTeam(ArrayList<Team> list) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入需要查询队伍的学校名称");
        String school = sc.next();
        ArrayList<Team> res = getIndex2(list, school);
        teamSelectSort(res);

    }
    //查询所有队伍
    public static void queryall(ArrayList<Team> list){

        for (int i = 0; i < list.size(); i++) {
            //得到每一个队伍对象
            Team tem = list.get(i);
            System.out.println(tem.getId() + "\t" + tem.getName() + "\t" + tem.getSchool() + "\t" + tem.getType() + "" +
                       "\t" + tem.getMember() + "\t" + tem.getTeacher());
        }
    }
    //bst搜索
    public static void bstSearch(ArrayList<Team> list) {
        BinarySearchTree bst = new BinarySearchTree();
        for(int i=0;i<list.size();i++) {
            bst.insert(list.get(i));
        }
        // 调用搜索示例
        System.out.println("请输入需要查找的参赛队编号：");
        Scanner input=new Scanner(System.in);
        String id = input.next();
        bst.search(id);
    }

    //叫号
    public static void call(ArrayList<Team> list) {
        Room.calling(list);
    }
    //打印表头信息

    //如若集合中有该查询的数据


    //判断id在集合中是否存在
    public static boolean contains(ArrayList<Team> list, String id) {
        //循环遍历集合得到每一个队伍对象
        //拿到队伍对象后，获取id并进行判断
        //存在返回true，不存在返回false
       /* for (int i = 0; i < list.size(); i++){
           Team tem= list.get (i);
           String tid=tem.getId();
           if(tid.equals(id)){
               return true;
           }
        }
        return false;*/
        return getIndex1(list, id) >= 0;
    }

    //通过id获取索引方法
    public static int getIndex1(ArrayList<Team> list, String id) {
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            //得到每一个队伍对象
            Team tem = list.get(i);
            //得到每一个队伍对象的id
            String tid = tem.getId();
            //拿着集合中队伍id和需要查询的id进行比较，若一样返回索引
            if (tid.equals(id)) {
                return i;

            }
        }
        //循环结束后未找到，说明不存在
        return -1;
    }

    public static ArrayList<Team> getIndex2(ArrayList<Team> list, String school) {
        ArrayList<Team> res = new ArrayList<Team>();
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            //得到每一个队伍对象
            Team tem = list.get(i);
            //得到每一个队伍对象的学校
            String tschool = tem.getSchool();
            //拿着集合中队伍的学校和需要查询的学校进行比较，若一样返回索引
            if (tschool.equals(school)) {
                res.add(tem);
            }
        }
        //循环结束后未找到，说明不存在
        return res;
    }

    public static void teamSelectSort(ArrayList<Team> list) {
        // 使用选择排序按照 id 升序排序
        // 总共要经过 N-1 轮比较
        for (int i = 0; i < list.size() - 1; i++) {
            int minIndex = i;
            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(j).getId().compareTo(list.get(minIndex).getId()) < 0) {
                    minIndex = j;// 记录目前能找到的最小值元素的下标
                }
            }
            // 交换位置
            Team temp = list.get(i);
            list.set(i, list.get(minIndex));
            list.set(minIndex, temp);
        }

        // 输出排序后的结果
        for (Team team : list) {
            System.out.println("参赛队编号: " + team.getId());
            System.out.println("参赛作品名称: " + team.getName());
            System.out.println("参赛学校: " + team.getSchool());
            System.out.println("赛事类别: " + team.getType());
            System.out.println("参赛者: " + team.getMember());
            System.out.println("指导教师: " + team.getTeacher());
            System.out.println();
        }
    }
}