devbox
黑客灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构实验—宿舍管理系统（C，Python，Java三种代码版本）_数据结构宿舍管理系统

作者：黑客灵魂 | 2024-08-05 05:55:02

赞

踩

数据结构宿舍管理系统

目录

 实验课程

实验内容

数据结构类型定义

模块划分

（C语言）详细代码设计

（python）详细代码设计

（Java）详细代码设计

测试数据及结果

 实验总结

需要制作相关课设，可私信支持有偿定制

 实验课程

课程名称：数据结构

实验名称：宿舍管理查询系统

实验目的：掌握数据结构的两种基本技术：查找和排序，根据实际情况选择效率较高的算法解决应用问题。

实验条件：计算机一台，Visual C++6.0

实验内容

问题描述

为宿舍管理人员设计一个宿舍管理查询系统, 程序采用交互工作方式，完成下列功能：

(1)建立合适的数据结构作为查找表并输入数据；

数据分别按关键字姓名、学号、房号进行排序(所学排序算法任选一种效率较高的算法)；

(2)设计查询菜单，按指定关键字姓名、学号、房号进行查询并输出结果，要求查询采用效率较高的算法实现；

(3)可以连续查询；

数据结构类型定义

  1. struct student{
  2.  
  3.     char name[20];  //姓名
  4.  
  5.     char num[20];   //学号
  6.  
  7.     char room[20];  //宿舍号
  8.  
  9. };
  10.  
  11. struct RoomSystem{
  12.  
  13.     struct student allStudentdata[60];  //存储学生信息的数组
  14.  
  15.     int size;   //系统中学生信息的数量
  16.  
  17. };

模块划分

void addStudent(struct RoomSystem* system)；//添加学生信息，存进管理系统结构体

void quickSort(struct student student[],int low, int high,const char* key)；//快排

int binarySearch(struct student student[],int low, int high,const char* key,const char* value)；//二分查找

void searchstudent(struct RoomSystem* RoomSystem,const char* key,const char* value)；//查找学生

int main()//主函数

（C语言）详细代码设计

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. //学生结构体
  5. struct student
  6. {
  7.     //都使用char，后续用strcmp比较
  8.     char name[20];  //姓名
  9.     char num[20];   //学号
  10.     char room[20];  //宿舍号
  11. };
  12.  
  13. //宿舍管理系统结构体
  14. struct RoomSystem
  15. {
  16.     //系统所有学生的数据
  17.     struct student allStudentdata[60];  //存储学生信息的数组
  18.     int size;   //系统中学生信息的数量
  19.  
  20. };
  21.  
  22. //添加学生信息，存进管理系统结构体
  23. void addStudent(struct RoomSystem* system){
  24.     printf("输入需要添加学生信息的数量：");
  25.     int number;
  26.     scanf("%d",&number);
  27.     for (int i = 1; i <=number; i++){
  28.         if(system->size < 60){
  29.         struct student* student = &system->allStudentdata[system->size++];
  30.         printf("输入第%d名学生信息\n姓名:",i);
  31.         scanf("%s", student->name);
  32.         printf("学号：");
  33.         scanf("%s", student->num);
  34.         printf("房号：");
  35.         scanf("%s", student->room);
  36.         printf("学生信息添加成功\n");
  37.     }else{
  38.         printf("学生人数已满，无法添加\n");
  39.     }
  40.     }
  41.     
  42. }
  43.  
  44. //查询学生信息
  45. //快排,传入学生数组，0和长度，还有查询值key
  46. void quickSort(struct student student[],int low, int high,const char* key){
  47.     
  48.     if(low<high){
  49.         //选取中间点
  50.         char dot[30];
  51.         int i = low-1;
  52.         strcpy(dot,student[high].name);
  53.  
  54.         for(int j = low;j<=high-1;j++){
  55.         //比较值，前者小于后者时返回小于0的输
  56.             if (strcmp(student[j].name, dot) < 0) {
  57.                 i++;
  58.                 // 交换元素
  59.                 struct student temp = student[i];
  60.                 student[i] = student[j];
  61.                 student[j] = temp;
  62.             }
  63.         }
  64.         struct student temp = student[i + 1];
  65.         student[i + 1] = student[high];
  66.         student[high] = temp;
  67.  
  68.         // 对左右两部分进行递归排序
  69.         quickSort(student, low, i, key);
  70.         quickSort(student, i + 2, high, key);
  71.     }
  72. }
  73. //对学生查询,已经进行了快排，可以使用二分查找提高效率
  74. int binarySearch(struct student student[],int low, int high,const char* key,const char* value){
  75.     while (low <= high){
  76.         int mid = low +(high-low)/2;
  77.         int compare;
  78.         if(strcmp(key, "name") == 0){
  79.             compare = strcmp(student[mid].name, value);
  80.         }else if (strcmp(key, "num") == 0) {
  81.             compare = strcmp(student[mid].num, value);
  82.         } else if (strcmp(key, "room") == 0) {
  83.             compare = strcmp(student[mid].room, value);
  84.         }
  85.  
  86.         // 如果关键字值与中间元素的值匹配，则返回中间元素的索引
  87.         if (compare == 0) {
  88.             return mid;
  89.         }
  90.         // 如果关键字值小于中间元素的值，则在左半部分继续搜索
  91.         if (compare > 0) {
  92.             high = mid - 1;
  93.         } else {
  94.             // 如果关键字值大于中间元素的值，则在右半部分继续搜索
  95.             low = mid + 1;
  96.         }
  97.     }
  98.     //未找到，返回-1
  99.     return -1;
  100. }
  101.  
  102. void searchstudent(struct RoomSystem* RoomSystem,const char* key,const char* value){
  103.     int result = binarySearch(RoomSystem->allStudentdata, 0, RoomSystem->size - 1, key, value);
  104.     if (result != -1) {
  105.         // 输出查询结果
  106.         printf("\n查询结果：\n姓名: %s\n学号: %s\n房号: %s\n", RoomSystem->allStudentdata[result].name,
  107.             RoomSystem->allStudentdata[result].num, RoomSystem->allStudentdata[result].room);
  108.     } else {
  109.         // 提示未找到匹配结果
  110.         printf("未找到该学生信息。\n");
  111.     }
  112. }
  113.  
  114. int main(){
  115.     struct RoomSystem roomsystem;
  116.     roomsystem.size = 0;
  117.  
  118.     //菜单
  119.     while (1) {
  120.         // 显示菜单选项
  121.         printf("\n1. 添加学生信息\n");
  122.         printf("2. 查询学生信息\n");
  123.         printf("3. 退出\n");
  124.  
  125.         int choice,num;
  126.         // 获取用户选择
  127.         printf("请输入选项：");
  128.         scanf("%d", &choice);
  129.  
  130.         switch (choice) {
  131.             case 1:
  132.                 addStudent(&roomsystem);    // 添加学生信息
  133.                 break;
  134.             case 2: {
  135.                 printf("\n1. 姓名查询\n2. 学号查询\n3. 房号查询\n");    // 显示查询菜单
  136.                 printf("输入查询学生的个数：");
  137.                 scanf("%d",&num);
  138.                 for (int i = 0; i < num; i++){
  139.                     int searchChoice;           // 获取查询关键字选择
  140.                 printf("请输入查询关键字：");
  141.                 scanf("%d", &searchChoice);
  142.  
  143.                 char searchValue[50];       // 获取查询值
  144.                 printf("请输入查询值：");
  145.                 scanf("%s", searchValue);
  146.  
  147.                 // 根据用户选择设置查询关键字
  148.                 const char* key;
  149.                 if (searchChoice == 1){
  150.                     key = "name";
  151.                 }else if (searchChoice == 2){
  152.                     key = "num";
  153.                 } else if (searchChoice == 3){
  154.                     key = "room";
  155.                 }else {
  156.                     // 处理无效的查询关键字
  157.                     printf("\n无效的查询关键字。\n");
  158.                     continue;
  159.                 }
  160.  
  161.                 // 使用快速排序算法对数据进行排序
  162.                 quickSort(roomsystem.allStudentdata, 0,roomsystem.size - 1, key);
  163.                 // 查询数据,注意传入的是整个结构体，而不是里面的数组
  164.                 searchstudent(&roomsystem,key,searchValue);
  165.                 }
  166.                 
  167.                 
  168.                 break;
  169.             }
  170.             case 3:
  171.                 // 退出程序
  172.                 printf("已退出系统\n");
  173.                 system("pause");
  174.                 return 0;
  175.             default:
  176.                 // 处理无效的选项
  177.                 printf("无效选项，请重新输入。\n");
  178.         }
  179.     }
  180.     system("pause");
  181.     return 0;
  182. }

（python）详细代码设计

  1. class Student:
  2.     def __init__(self, name, num, room):
  3.         self.name = name
  4.         self.num = num
  5.         self.room = room
  6.  
  7. class RoomSystem:
  8.     def __init__(self):
  9.         self.all_student_data = []
  10.         self.size = 0
  11.  
  12. def add_student(room_system):
  13.     print("输入需要添加学生信息的数量：")
  14.     number = int(input())
  15.     for i in range(1, number + 1):
  16.         if room_system.size < 60:
  17.             name = input(f"输入第{i}名学生信息\n姓名:")
  18.             num = input("学号：")
  19.             room = input("房号：")
  20.             student = Student(name, num, room)
  21.             room_system.all_student_data.append(student)
  22.             room_system.size += 1
  23.             print("学生信息添加成功")
  24.         else:
  25.             print("学生人数已满，无法添加")
  26.  
  27. def quick_sort(student_list, key):
  28.     if len(student_list) <= 1:
  29.         return student_list
  30.  
  31.     pivot_index = len(student_list) // 2
  32.     pivot = getattr(student_list[pivot_index], key)
  33.  
  34.     left = [student for student in student_list if getattr(student, key) < pivot]
  35.     middle = [student for student in student_list if getattr(student, key) == pivot]
  36.     right = [student for student in student_list if getattr(student, key) > pivot]
  37.  
  38.     return quick_sort(left, key) + middle + quick_sort(right, key)
  39.  
  40. def binary_search(student_list, key, value):
  41.     low, high = 0, len(student_list) - 1
  42.  
  43.     while low <= high:
  44.         mid = (low + high) // 2
  45.         compare_result = getattr(student_list[mid], key) - value
  46.  
  47.         if compare_result == 0:
  48.             return mid
  49.         elif compare_result > 0:
  50.             high = mid - 1
  51.         else:
  52.             low = mid + 1
  53.  
  54.     return -1
  55.  
  56. def search_student(room_system, key, value):
  57.     sorted_students = quick_sort(room_system.all_student_data, key)
  58.     result = binary_search(sorted_students, key, value)
  59.  
  60.     if result != -1:
  61.         print("\n查询结果：\n姓名: {}\n学号: {}\n房号: {}".format(
  62.             sorted_students[result].name,
  63.             sorted_students[result].num,
  64.             sorted_students[result].room
  65.         ))
  66.     else:
  67.         print("未找到该学生信息。")
  68.  
  69. def main():
  70.     room_system = RoomSystem()
  71.  
  72.     while True:
  73.         print("\n1. 添加学生信息")
  74.         print("2. 查询学生信息")
  75.         print("3. 退出")
  76.  
  77.         choice = int(input("请输入选项："))
  78.  
  79.         if choice == 1:
  80.             add_student(room_system)
  81.         elif choice == 2:
  82.             print("\n1. 姓名查询\n2. 学号查询\n3. 房号查询")
  83.             num = int(input("输入查询学生的个数："))
  84.             for _ in range(num):
  85.                 search_choice = int(input("请输入查询关键字："))
  86.                 search_value = input("请输入查询值：")
  87.                 key = ""
  88.                 if search_choice == 1:
  89.                     key = "name"
  90.                 elif search_choice == 2:
  91.                     key = "num"
  92.                 elif search_choice == 3:
  93.                     key = "room"
  94.                 else:
  95.                     print("\n无效的查询关键字。")
  96.                     continue
  97.  
  98.                 room_system.all_student_data = quick_sort(room_system.all_student_data, key)
  99.                 search_student(room_system, key, search_value)
  100.         elif choice == 3:
  101.             print("已退出系统")
  102.             break
  103.         else:
  104.             print("无效选项，请重新输入。")
  105.  
  106. if __name__ == "__main__":
  107.     main()

（Java）详细代码设计

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.Scanner;
  5.  
  6. class Student {
  7.     String name;
  8.     String num;
  9.     String room;
  10.  
  11.     public Student(String name, String num, String room) {
  12.         this.name = name;
  13.         this.num = num;
  14.         this.room = room;
  15.     }
  16. }
  17.  
  18. class RoomSystem {
  19.     ArrayList<Student> allStudentData = new ArrayList<>();
  20.     int size = 0;
  21. }
  22.  
  23. public class DormitoryManagementSystem {
  24.  
  25.     public static void addStudent(RoomSystem roomSystem) {
  26.         Scanner scanner = new Scanner(System.in);
  27.         System.out.print("输入需要添加学生信息的数量：");
  28.         int number = scanner.nextInt();
  29.  
  30.         for (int i = 1; i <= number; i++) {
  31.             if (roomSystem.size < 60) {
  32.                 System.out.printf("输入第%d名学生信息\n姓名:", i);
  33.                 String name = scanner.next();
  34.                 System.out.print("学号：");
  35.                 String num = scanner.next();
  36.                 System.out.print("房号：");
  37.                 String room = scanner.next();
  38.  
  39.                 Student student = new Student(name, num, room);
  40.                 roomSystem.allStudentData.add(student);
  41.                 roomSystem.size++;
  42.                 System.out.println("学生信息添加成功");
  43.             } else {
  44.                 System.out.println("学生人数已满，无法添加");
  45.             }
  46.         }
  47.     }
  48.  
  49.     public static void quickSort(ArrayList<Student> studentList, final String key) {
  50.         Collections.sort(studentList, Comparator.comparing(s -> {
  51.             switch (key) {
  52.                 case "name":
  53.                     return s.name;
  54.                 case "num":
  55.                     return s.num;
  56.                 case "room":
  57.                     return s.room;
  58.                 default:
  59.                     return "";
  60.             }
  61.         }));
  62.     }
  63.  
  64.     public static int binarySearch(ArrayList<Student> studentList, String key, String value) {
  65.         int low = 0;
  66.         int high = studentList.size() - 1;
  67.  
  68.         while (low <= high) {
  69.             int mid = (low + high) / 2;
  70.             int compareResult = switch (key) {
  71.                 case "name" -> studentList.get(mid).name.compareTo(value);
  72.                 case "num" -> studentList.get(mid).num.compareTo(value);
  73.                 case "room" -> studentList.get(mid).room.compareTo(value);
  74.                 default -> 0;
  75.             };
  76.  
  77.             if (compareResult == 0) {
  78.                 return mid;
  79.             } else if (compareResult > 0) {
  80.                 high = mid - 1;
  81.             } else {
  82.                 low = mid + 1;
  83.             }
  84.         }
  85.  
  86.         return -1;
  87.     }
  88.  
  89.     public static void searchStudent(RoomSystem roomSystem, String key, String value) {
  90.         quickSort(roomSystem.allStudentData, key);
  91.         int result = binarySearch(roomSystem.allStudentData, key, value);
  92.  
  93.         if (result != -1) {
  94.             System.out.printf("\n查询结果：\n姓名: %s\n学号: %s\n房号: %s\n",
  95.                     roomSystem.allStudentData.get(result).name,
  96.                     roomSystem.allStudentData.get(result).num,
  97.                     roomSystem.allStudentData.get(result).room);
  98.         } else {
  99.             System.out.println("未找到该学生信息。");
  100.         }
  101.     }
  102.  
  103.     public static void main(String[] args) {
  104.         RoomSystem roomSystem = new RoomSystem();
  105.         Scanner scanner = new Scanner(System.in);
  106.  
  107.         while (true) {
  108.             System.out.println("\n1. 添加学生信息");
  109.             System.out.println("2. 查询学生信息");
  110.             System.out.println("3. 退出");
  111.  
  112.             System.out.print("请输入选项：");
  113.             int choice = scanner.nextInt();
  114.  
  115.             if (choice == 1) {
  116.                 addStudent(roomSystem);
  117.             } else if (choice == 2) {
  118.                 System.out.println("\n1. 姓名查询\n2. 学号查询\n3. 房号查询");
  119.                 System.out.print("输入查询学生的个数：");
  120.                 int num = scanner.nextInt();
  121.                 for (int i = 0; i < num; i++) {
  122.                     System.out.print("请输入查询关键字：");
  123.                     int searchChoice = scanner.nextInt();
  124.                     System.out.print("请输入查询值：");
  125.                     String searchValue = scanner.next();
  126.  
  127.                     String key;
  128.                     switch (searchChoice) {
  129.                         case 1 -> key = "name";
  130.                         case 2 -> key = "num";
  131.                         case 3 -> key = "room";
  132.                         default -> {
  133.                             System.out.println("\n无效的查询关键字。");
  134.                             continue;
  135.                         }
  136.                     }
  137.  
  138.                     searchStudent(roomSystem, key, searchValue);
  139.                 }
  140.             } else if (choice == 3) {
  141.                 System.out.println("已退出系统");
  142.                 break;
  143.             } else {
  144.                 System.out.println("无效选项，请重新输入。");
  145.             }
  146.         }
  147.     }
  148. }

测试数据及结果

 3d683f67c4134b4ab539eb782204eba6.png

 实验总结

哈哈，到了这里就得你们自己写喽 

喜欢的小伙伴记得点个关注，给个三连呐~ 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/黑客灵魂/article/detail/931053
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号