python版管理系统（顺序表与链表两种方式实现）

1.图书管理系统*
顺序表实现

点击查看代码

# 图书管理系统 - 顺序表实现
class BookList:
    def __init__(self):
        self.books = []  # 使用列表存储图书数据

    def input_books(self):
        """批量输入图书信息"""
        print("请输入图书信息(书号 书名 价格)，每本一行，输入'0 0 0'结束：")
        while True:
            info = input().strip()
            if info == '0 0 0':
                break
            try:
                book_id, title, price = info.split()
                self.add_book([book_id, title, float(price)])
            except (ValueError, IndexError):
                print("格式错误！请使用: 书号 书名 价格")

    def add_book(self, book_info):
        """添加单本图书"""
        self.books.append(book_info)
        print(f"成功添加图书: {book_info[1]}")

    def get_book_count(self):
        """获取图书数量"""
        return len(self.books)

    def display_books(self):
        """显示所有图书信息"""
        if not self.books:
            print("无图书记录")
            return

        print("\n{:<10}{:<20}{:<10}".format("书号", "书名", "价格"))
        print("-" * 40)
        for book in self.books:
            print("{:<10}{:<20}{:<10.2f}".format(*book))
        print("-" * 40)
        print(f"总计: {self.get_book_count()}本图书\n")

    def sort_books(self):
        """按价格降序排序"""
        self.books.sort(key=lambda x: x[2], reverse=True)
        print("已按价格降序排序")
        self.display_books()

    def adjust_prices(self):
        """根据平均价格调整价格"""
        if not self.books:
            print("无图书记录")
            return

        # 计算平均价格
        total = sum(book[2] for book in self.books)
        avg_price = total / len(self.books)
        print(f"原平均价格: {avg_price:.2f}")

        # 调整价格
        for book in self.books:
            if book[2] < avg_price:
                book[2] *= 1.2  # 低于平均价提高20%
            else:
                book[2] *= 1.1  # 高于平均价提高10%

        print("价格调整完成")
        self.display_books()

    def reverse_order(self):
        """逆序图书列表"""
        self.books.reverse()
        print("图书顺序已逆序")
        self.display_books()

    def find_expensive(self):
        """查找最高价图书"""
        if not self.books:
            print("无图书记录")
            return

        # 找出最高价格
        max_price = max(book[2] for book in self.books)

        # 找出所有价格等于最高价的图书
        expensive_books = [book for book in self.books if abs(book[2] - max_price) < 0.001]

        print(f"最高价格: {max_price:.2f}, 共{len(expensive_books)}本:")
        print("{:<10}{:<20}{:<10}".format("书号", "书名", "价格"))
        for book in expensive_books:
            print("{:<10}{:<20}{:<10.2f}".format(*book))

    def search_by_title(self, title):
        """按书名搜索"""
        results = [book for book in self.books if title.lower() in book[1].lower()]

        if not results:
            print(f"未找到包含'{title}'的图书")
            return

        print(f"找到{len(results)}本相关图书:")
        print("{:<10}{:<20}{:<10}".format("书号", "书名", "价格"))
        for book in results:
            print("{:<10}{:<20}{:<10.2f}".format(*book))

    def search_by_position(self, pos):
        """按位置搜索"""
        try:
            pos = int(pos)
            if 1 <= pos <= len(self.books):
                book = self.books[pos - 1]
                print("{:<10}{:<20}{:<10}".format("书号", "书名", "价格"))
                print("{:<10}{:<20}{:<10.2f}".format(*book))
            else:
                print("位置无效！")
        except ValueError:
            print("请输入有效数字！")

    def insert_book(self, pos, book_info):
        """在指定位置插入图书"""
        try:
            pos = int(pos)
            if 1 <= pos <= len(self.books) + 1:
                self.books.insert(pos - 1, book_info)
                print(f"成功在位置{pos}插入图书: {book_info[1]}")
                self.display_books()
            else:
                print("位置无效！")
        except ValueError:
            print("请输入有效数字！")

    def delete_book(self, pos):
        """删除指定位置图书"""
        try:
            pos = int(pos)
            if 1 <= pos <= len(self.books):
                deleted_book = self.books.pop(pos - 1)
                print(f"已删除: {deleted_book[1]}")
                self.display_books()
            else:
                print("位置无效！")
        except ValueError:
            print("请输入有效数字！")

    def remove_duplicates(self):
        """按书号去重"""
        if not self.books:
            print("无图书记录")
            return

        unique_books = []
        seen_ids = set()

        for book in self.books:
            if book[0] not in seen_ids:
                unique_books.append(book)
                seen_ids.add(book[0])

        removed_count = len(self.books) - len(unique_books)
        self.books = unique_books

        print(f"已移除{removed_count}本重复图书")
        self.display_books()

# 顺序表系统菜单
def main():
    book_sys = BookList()
    while True:
        print("\n" + "=" * 40)
        print("图书管理系统")
        print("=" * 40)
        print("1. 批量输入图书")
        print("2. 显示所有图书")
        print("3. 按价格排序")
        print("4. 调整价格")
        print("5. 逆序图书列表")
        print("6. 查找最贵图书")
        print("7. 按书名搜索")
        print("8. 按位置搜索")
        print("9. 插入图书")
        print("10.删除图书")
        print("11.去重(按书号)")
        print("0. 返回主菜单")
        print("=" * 40)

        choice = input("请选择操作: ")

        if choice == '0':
            break

        elif choice == '1':
            book_sys.input_books()

        elif choice == '2':
            book_sys.display_books()

        elif choice == '3':
            book_sys.sort_books()

        elif choice == '4':
            book_sys.adjust_prices()

        elif choice == '5':
            book_sys.reverse_order()

        elif choice == '6':
            book_sys.find_expensive()

        elif choice == '7':
            title = input("请输入书名: ")
            book_sys.search_by_title(title)

        elif choice == '8':
            pos = input("请输入位置序号: ")
            book_sys.search_by_position(pos)

        elif choice == '9':
            pos = input("请输入插入位置: ")
            info = input("请输入图书信息(书号 书名 价格): ").split()
            if len(info) == 3:
                try:
                    book_info = [info[0], info[1], float(info[2])]
                    book_sys.insert_book(pos, book_info)
                except ValueError:
                    print("价格格式错误！")
            else:
                print("输入格式错误！")

        elif choice == '10':
            pos = input("请输入删除位置: ")
            book_sys.delete_book(pos)

        elif choice == '11':
            book_sys.remove_duplicates()

        else:
            print("无效选择，请重新输入！")

# 程序入口
if __name__ == "__main__":
    main()

链表实现

点击查看代码

class LinkNode:
    """链表节点"""
    def __init__(self, data=None):
        self.data = data  # [书号, 书名, 价格]
        self.next = None


class LinkedList:
    """基于链表实现的图书管理系统"""
    def __init__(self):
        self.head = LinkNode()  # 头节点
        self.count = 0  # 图书数量计数器

    def input_books(self):
        """批量输入图书信息"""
        print("请输入图书信息(书号 书名 价格)，每本一行，输入'0 0 0'结束：")
        while True:
            info = input().strip()
            if info == '0 0 0':
                break
            try:
                book_id, title, price = info.split()
                self.add_book([book_id, title, float(price)])
            except (ValueError, IndexError):
                print("格式错误！请使用: 书号 书名 价格")

    def add_book(self, book_info):
        """添加单本图书(尾插法)"""
        new_node = LinkNode(book_info)
        current = self.head

        # 找到链表尾部
        while current.next:
            current = current.next

        current.next = new_node
        self.count += 1

    def get_book_count(self):
        """获取图书数量"""
        return self.count

    def display_books(self):
        """显示所有图书信息"""
        if self.count == 0:
            print("无图书记录")
            return

        current = self.head.next
        print("\n{:<10}{:<20}{:<10}".format("书号", "书名", "价格"))
        print("-" * 40)
        while current:
            print("{:<10}{:<20}{:<10.2f}".format(*current.data))
            current = current.next
        print("-" * 40)
        print(f"总计: {self.count}本图书\n")

    def sort_books(self):
        """按价格降序排序"""
        if self.count == 0:
            print("无图书记录")
            return
        # 将链表数据存入列表
        books = []
        current = self.head.next
        while current:
            books.append(current.data)
            current = current.next

        # 排序列表
        books.sort(key=lambda x: x[2], reverse=True)

        # 重建链表
        self.head.next = None
        self.count = 0
        for book in books:
            self.add_book(book)

        print("已按价格降序排序")
        self.display_books()

    def adjust_prices(self):
        """根据平均价格调整价格"""
        if self.count == 0:
            print("无图书记录")
            return

        # 计算平均价格
        total = 0
        current = self.head.next
        while current:
            total += current.data[2]
            current = current.next
        avg_price = total / self.count
        print(f"原平均价格: {avg_price:.2f}")
        # 调整价格
        current = self.head.next
        while current:
            if current.data[2] < avg_price:
                current.data[2] *= 1.2  # 低于平均价提高20%
            else:
                current.data[2] *= 1.1  # 高于平均价提高10%
            current = current.next

        print("价格调整完成")
        self.display_books()

    def reverse_order(self):
        """反转链表"""
        if self.count <= 1:
            print("图书顺序已逆序" if self.count == 1 else "无图书记录")
            return

        prev = None
        current = self.head.next

        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node

        self.head.next = prev
        print("链表已逆序")
        self.display_books()

    def find_expensive(self):
        """查找最高价图书"""
        if self.count == 0:
            print("无图书记录")
            return

        # 寻找最高价格
        max_price = 0
        current = self.head.next
        while current:
            if current.data[2] > max_price:
                max_price = current.data[2]
            current = current.next

        # 收集最高价图书
        expensive_books = []
        current = self.head.next
        while current:
            if abs(current.data[2] - max_price) < 0.001:  # 浮点数比较容差
                expensive_books.append(current.data)
            current = current.next

        print(f"最高价格: {max_price:.2f}, 共{len(expensive_books)}本:")
        print("{:<10}{:<20}{:<10}".format("书号", "书名", "价格"))
        for book in expensive_books:
            print("{:<10}{:<20}{:<10.2f}".format(*book))

    def search_by_title(self, title):
        """按书名搜索"""
        if self.count == 0:
            print("无图书记录")
            return

        results = []
        current = self.head.next
        while current:
            if title.lower() in current.data[1].lower():
                results.append(current.data)
            current = current.next

        if not results:
            print(f"未找到包含'{title}'的图书")
            return

        print(f"找到{len(results)}本相关图书:")
        print("{:<10}{:<20}{:<10}".format("书号", "书名", "价格"))
        for book in results:
            print("{:<10}{:<20}{:<10.2f}".format(*book))

    def search_by_position(self, pos):
        """按位置搜索"""
        if self.count == 0:
            print("无图书记录")
            return

        try:
            pos = int(pos)
            if 1 <= pos <= self.count:
                current = self.head.next
                current_pos = 1
                while current_pos < pos:
                    current = current.next
                    current_pos += 1
                print("{:<10}{:<20}{:<10}".format("书号", "书名", "价格"))
                print("{:<10}{:<20}{:<10.2f}".format(*current.data))
            else:
                print("位置无效！")
        except ValueError:
            print("请输入有效数字！")

    def insert_book(self, pos, book_info):
        """在指定位置插入图书"""
        try:
            pos = int(pos)
            if pos < 1 or pos > self.count + 1:
                print("位置无效！")
                return

            # 创建新节点
            new_node = LinkNode(book_info)

            # 找到插入位置的前一个节点
            prev = self.head
            current_pos = 1

            # 移动到插入位置的前一个节点
            while current_pos < pos:
                prev = prev.next
                current_pos += 1

            # 插入新节点
            new_node.next = prev.next
            prev.next = new_node
            self.count += 1

            print(f"成功在位置{pos}插入图书: {book_info[1]}")
            self.display_books()
        except ValueError:
            print("请输入有效数字！")

    def delete_book(self, pos):
        """删除指定位置图书"""
        try:
            pos = int(pos)
            if pos < 1 or pos > self.count:
                print("位置无效！")
                return

            # 找到要删除节点的前一个节点
            prev = self.head
            current_pos = 1

            # 移动到要删除节点的前一个节点
            while current_pos < pos:
                prev = prev.next
                current_pos += 1

            # 删除节点
            deleted_node = prev.next
            deleted_title = deleted_node.data[1]
            prev.next = deleted_node.next
            self.count -= 1

            print(f"已删除: {deleted_title}")
            self.display_books()
        except ValueError:
            print("请输入有效数字！")

    def remove_duplicates(self):
        """按书号去重"""
        if self.count == 0:
            print("无图书记录")
            return

        # 用于跟踪已经出现过的书号
        seen_ids = set()

        prev = self.head
        current = self.head.next
        removed_count = 0

        while current:
            book_id = current.data[0]
            if book_id in seen_ids:
                # 发现重复，删除当前节点
                prev.next = current.next
                current = current.next
                removed_count += 1
                self.count -= 1
            else:
                # 新书号，添加到已见集合并继续遍历
                seen_ids.add(book_id)
                prev = current
                current = current.next

        print(f"已移除{removed_count}本重复图书")
        self.display_books()

# 链表系统菜单
def main():
    """链表图书管理系统菜单"""
    book_sys = LinkedList()

    while True:
        print("\n" + "=" * 40)
        print("图书管理系统")
        print("=" * 40)
        print("1. 批量输入图书")
        print("2. 显示所有图书")
        print("3. 按价格排序")
        print("4. 调整价格")
        print("5. 逆序图书列表")
        print("6. 查找最贵图书")
        print("7. 按书名搜索")
        print("8. 按位置搜索")
        print("9. 插入图书")
        print("10.删除图书")
        print("11.去重(按书号)")
        print("0. 返回主菜单")
        print("=" * 40)

        choice = input("请选择操作: ")

        if choice == '0':
            break
        elif choice == '1':
            book_sys.input_books()
        elif choice == '2':
            book_sys.display_books()
        elif choice == '3':
            book_sys.sort_books()
        elif choice == '4':
            book_sys.adjust_prices()
        elif choice == '5':
            book_sys.reverse_order()
        elif choice == '6':
            book_sys.find_expensive()
        elif choice == '7':
            title = input("请输入书名: ")
            book_sys.search_by_title(title)
        elif choice == '8':
            pos = input("请输入位置序号: ")
            book_sys.search_by_position(pos)
        elif choice == '9':
            pos = input("请输入插入位置: ")
            info = input("请输入图书信息(书号 书名 价格): ").split()
            if len(info) == 3:
                try:
                    book_info = [info[0], info[1], float(info[2])]
                    book_sys.insert_book(pos, book_info)
                except ValueError:
                    print("价格格式错误！")
            else:
                print("输入格式错误！")
        elif choice == '10':
            pos = input("请输入删除位置: ")
            book_sys.delete_book(pos)
        elif choice == '11':
            book_sys.remove_duplicates()
        else:
            print("无效选择，请重新输入！")


# 程序入口
if __name__ == "__main__":
    main()

代码测试数据：

点击查看代码

B022 计算机安全原理 94.60
B008 编译原理 85.30
B015 深度学习 132.00
B003 Python编程从入门到精通 59.80
B020 区块链技术原理 102.80
B001 计算机网络 78.50
B011 机器学习实战 74.20
B017 计算机图形学 77.60
B023 计算机组成与设计 105.50
B005 数据库系统概念 88.60
B013 计算机网络 78.50
B010 计算机组成与设计 105.50
B002 深入理解计算机系统 125.00
B019 Web开发权威指南 58.30
B021 Linux内核设计与实现 89.95
B012 C++ Primer 86.90
B006 人工智能：一种现代方法 115.00
B016 软件工程实践 63.40
B009 数据结构与算法分析 67.80
B018 信息论基础 69.90
B004 算法导论 99.90
B007 操作系统精髓 92.40
B014 Java核心技术 81.75
B024 人月神话 46.80
B025 代码大全 82.45
0 0 0

2.学生成绩管理系统
顺序表实现

点击查看代码

class StudentList:
    def __init__(self):
        self.students = []  # 使用列表存储学生数据，格式: [学号, 姓名, 班级, 高数, 英语, Python]

    def input_students(self):
        """批量输入学生信息"""
        print("请输入学生信息(学号 姓名 班级 高数成绩 英语成绩 Python成绩)，每行一个，输入'0'结束：")
        print("示例: 2023001 张三 计算机1班 85 92 88")
        while True:
            info = input().strip()
            if info == '0':
                break
            try:
                parts = info.split()
                if len(parts) != 6:
                    print("输入格式错误！请提供6个值：学号 姓名 班级 高数成绩 英语成绩 Python成绩")
                    continue

                # 提取各部分信息
                student_id, name, class_name, math, english, python = parts
                student_info = [
                    student_id,
                    name,
                    class_name,
                    float(math),
                    float(english),
                    float(python)
                ]
                self.add_student(student_info)
            except ValueError:
                print("成绩格式错误！请确保成绩为数字")

    def add_student(self, student_info):
        """添加单个学生"""
        self.students.append(student_info)
        print(f"成功添加学生: {student_info[1]} ({student_info[0]})")

    def get_student_count(self):
        """获取学生数量"""
        return len(self.students)

    def display_students(self):
        """显示所有学生信息"""
        if not self.students:
            print("无学生记录")
            return

        # 格式化表头
        header = "{:<10}{:<8}{:<12}{:<8}{:<8}{:<10}{:<10}".format(
            "学号", "姓名", "班级", "高数", "英语", "Python", "平均分"
        )
        print("\n" + header)
        print("-" * len(header))

        # 显示每个学生的信息
        for student in self.students:
            # 计算平均分
            avg_score = round((student[3] + student[4] + student[5]) / 3, 1)
            # 格式化行
            row = "{:<10}{:<8}{:<12}{:<8.1f}{:<8.1f}{:<10.1f}{:<10.1f}".format(
                student[0], student[1], student[2],
                student[3], student[4], student[5], avg_score
            )
            print(row)

        print("-" * len(header))
        print(f"总计: {self.get_student_count()}名学生\n")

    def sort_students(self, subject='平均分'):
        """按指定科目成绩降序排序"""
        if not self.students:
            print("无学生记录")
            return

        # 确定排序键
        subject_index_map = {
            '高数': 3,
            '英语': 4,
            'Python': 5,
            '平均分': -1  # 特殊处理
        }

        if subject not in subject_index_map:
            print(f"无效科目: {subject}，按平均分排序")
            subject = '平均分'

        # 如果是按平均分排序，需要计算平均值
        if subject == '平均分':
            def sort_key(student):
                return (student[3] + student[4] + student[5]) / 3
        else:
            index = subject_index_map[subject]
            sort_key = lambda student: student[index]

        self.students.sort(key=sort_key, reverse=True)
        print(f"已按{subject}成绩降序排序")
        self.display_students()

    def analyze_scores(self):
        """各科成绩分析"""
        if not self.students:
            print("无学生记录")
            return

        # 收集各科成绩数据
        math_scores = [s[3] for s in self.students]
        english_scores = [s[4] for s in self.students]
        python_scores = [s[5] for s in self.students]

        # 计算各科统计数据
        subjects = ['高数', '英语', 'Python']
        score_lists = [math_scores, english_scores, python_scores]

        # 表头
        print("\n{:<10}{:<10}{:<10}{:<10}{:<10}".format(
            "科目", "平均分", "最高分", "最低分", "及格率"
        ))
        print("-" * 50)

        # 计算并显示各科数据
        for subj, scores in zip(subjects, score_lists):
            avg = sum(scores) / len(scores)
            max_score = max(scores)
            min_score = min(scores)
            pass_rate = sum(1 for score in scores if score >= 60) / len(scores)

            print("{:<10}{:<10.1f}{:<10.1f}{:<10.1f}{:<10.1%}".format(
                subj, avg, max_score, min_score, pass_rate
            ))

        print("-" * 50)

    def class_performance(self):
        """班级表现分析"""
        if not self.students:
            print("无学生记录")
            return

        # 按班级分组
        class_data = {}
        for student in self.students:
            class_name = student[2]
            if class_name not in class_data:
                class_data[class_name] = {
                    'students': [],
                    'math_scores': [],
                    'english_scores': [],
                    'python_scores': [],
                    'avg_scores': []
                }

            class_data[class_name]['students'].append(student)
            class_data[class_name]['math_scores'].append(student[3])
            class_data[class_name]['english_scores'].append(student[4])
            class_data[class_name]['python_scores'].append(student[5])
            class_data[class_name]['avg_scores'].append((student[3] + student[4] + student[5]) / 3)

        # 表头
        header = "{:<12}{:<8}{:<10}{:<10}{:<10}{:<10}".format(
            "班级", "人数", "高数均分", "英语均分", "Python均分", "总分均分"
        )
        print("\n" + header)
        print("-" * len(header))

        # 计算并显示各班级数据
        for class_name, data in class_data.items():
            math_avg = sum(data['math_scores']) / len(data['math_scores'])
            eng_avg = sum(data['english_scores']) / len(data['english_scores'])
            py_avg = sum(data['python_scores']) / len(data['python_scores'])
            total_avg = sum(data['avg_scores']) / len(data['avg_scores'])

            print("{:<12}{:<8}{:<10.1f}{:<10.1f}{:<10.1f}{:<10.1f}".format(
                class_name, len(data['students']), math_avg, eng_avg, py_avg, total_avg
            ))

        print("-" * len(header))

    def reverse_order(self):
        """反转学生顺序"""
        if not self.students:
            print("无学生记录")
            return

        self.students.reverse()
        print("学生顺序已逆序")
        self.display_students()

    def find_top_students(self, subject='平均分'):
        """查找指定科目最高分学生"""
        if not self.students:
            print("无学生记录")
            return

        # 确定查找科目
        subject_index_map = {
            '高数': 3,
            '英语': 4,
            'Python': 5,
            '平均分': -1
        }

        if subject not in subject_index_map:
            print(f"无效科目: {subject}，按平均分查找")
            subject = '平均分'

        # 查找最高分
        if subject == '平均分':
            scores = [(s[3] + s[4] + s[5]) / 3 for s in self.students]
            max_score = max(scores)
        else:
            index = subject_index_map[subject]
            max_score = max(s[index] for s in self.students)

        # 收集最高分学生
        top_students = []
        for student in self.students:
            if subject == '平均分':
                avg = (student[3] + student[4] + student[5]) / 3
                if abs(avg - max_score) < 0.001:
                    top_students.append(student)
            else:
                if abs(student[subject_index_map[subject]] - max_score) < 0.001:
                    top_students.append(student)

        print(f"\n{subject}最高分: {max_score:.1f}, 共{len(top_students)}人:")
        self._display_students(top_students)

    def search_by_name(self, name):
        """按姓名搜索"""
        if not self.students:
            print("无学生记录")
            return

        results = [s for s in self.students if name.lower() in s[1].lower()]

        if not results:
            print(f"未找到包含'{name}'的学生")
            return

        print(f"找到{len(results)}名学生:")
        self._display_students(results)

    def search_by_id(self, student_id):
        """按学号搜索"""
        if not self.students:
            print("无学生记录")
            return

        results = [s for s in self.students if s[0] == student_id]

        if not results:
            print(f"未找到学号为'{student_id}'的学生")
            return

        print(f"找到学号为'{student_id}'的学生:")
        self._display_students(results)

    def search_by_class(self, class_name):
        """按班级搜索"""
        if not self.students:
            print("无学生记录")
            return

        results = [s for s in self.students if class_name.lower() in s[2].lower()]

        if not results:
            print(f"未找到班级包含'{class_name}'的学生")
            return

        print(f"找到班级包含'{class_name}'的{len(results)}名学生:")
        self._display_students(results)

    def _display_students(self, students):
        """显示指定的学生列表"""
        if not students:
            return

        # 格式化表头
        header = "{:<10}{:<8}{:<12}{:<8}{:<8}{:<10}{:<10}".format(
            "学号", "姓名", "班级", "高数", "英语", "Python", "平均分"
        )
        print("\n" + header)
        print("-" * len(header))

        # 显示每个学生的信息
        for student in students:
            # 计算平均分
            avg_score = round((student[3] + student[4] + student[5]) / 3, 1)
            # 格式化行
            row = "{:<10}{:<8}{:<12}{:<8.1f}{:<8.1f}{:<10.1f}{:<10.1f}".format(
                student[0], student[1], student[2],
                student[3], student[4], student[5], avg_score
            )
            print(row)

        print("-" * len(header))

    def insert_student(self, pos, student_info):
        """在指定位置插入学生"""
        try:
            pos = int(pos)
            if 1 <= pos <= len(self.students) + 1:
                self.students.insert(pos - 1, student_info)
                print(f"成功在位置{pos}插入学生: {student_info[1]}")
                self.display_students()
            else:
                print("位置无效！")
        except ValueError:
            print("请输入有效数字！")

    def delete_student(self, student_id):
        """按学号删除学生"""
        if not self.students:
            print("无学生记录")
            return

        for i, student in enumerate(self.students):
            if student[0] == student_id:
                deleted_student = self.students.pop(i)
                print(f"已删除学号为 '{student_id}' 的学生: {deleted_student[1]}")
                self.display_students()
                return

        print(f"未找到学号为 '{student_id}' 的学生")

    def remove_duplicates(self):
        """按学号去重"""
        if not self.students:
            print("无学生记录")
            return

        # 用于跟踪已经出现过的学号
        seen_ids = set()
        unique_students = []

        for student in self.students:
            if student[0] not in seen_ids:
                unique_students.append(student)
                seen_ids.add(student[0])

        removed_count = len(self.students) - len(unique_students)
        self.students = unique_students

        print(f"已移除{removed_count}名重复学生")
        self.display_students()

    def calculate_class_average(self):
        """计算各班级平均分"""
        if not self.students:
            print("无学生记录")
            return

        # 按班级分组
        class_data = {}
        for student in self.students:
            class_name = student[2]
            if class_name not in class_data:
                class_data[class_name] = {
                    'students': [],
                    'avg_scores': []
                }

            class_data[class_name]['students'].append(student)
            class_data[class_name]['avg_scores'].append(
                (student[3] + student[4] + student[5]) / 3
            )

        # 表头
        header = "{:<12}{:<10}{:<10}{:<10}".format(
            "班级", "人数", "平均分", "状态"
        )
        print("\n" + header)
        print("-" * len(header))

        # 计算总体平均分
        total_avg = sum(
            (s[3] + s[4] + s[5]) / 3 for s in self.students
        ) / len(self.students)

        # 计算并显示各班级数据
        for class_name, data in class_data.items():
            class_avg = sum(data['avg_scores']) / len(data['avg_scores'])
            status = "超过平均水平" if class_avg > total_avg else "低于平均水平"
            if abs(class_avg - total_avg) < 0.001:
                status = "达到平均水平"

            print("{:<12}{:<10}{:<10.1f}{:<10}".format(
                class_name, len(data['students']), class_avg, status
            ))

        print("-" * len(header))
        print(f"总体平均分: {total_avg:.1f}")


# 学生系统菜单
def main_menu():
    """增强版学生管理系统主菜单"""
    system = StudentList()

    while True:
        print("\n" + "=" * 50)
        print("增强版学生管理系统")
        print("=" * 50)
        print("1. 批量输入学生")
        print("2. 显示所有学生")
        print("3. 按成绩排序")
        print("4. 各科成绩分析")
        print("5. 班级表现分析")
        print("6. 逆序学生列表")
        print("7. 查找最高分学生")
        print("8. 按姓名搜索")
        print("9. 按学号搜索")
        print("10.按班级搜索")
        print("11.插入学生")
        print("12.删除学生")
        print("13.去重(按学号)")
        print("14.班级平均分分析")
        print("0. 退出系统")
        print("=" * 50)

        choice = input("请选择操作: ")

        if choice == '0':
            print("感谢使用学生管理系统!")
            break
        elif choice == '1':
            system.input_students()
        elif choice == '2':
            system.display_students()
        elif choice == '3':
            subject = input("请选择排序科目(高数/英语/Python/平均分): ").strip()
            system.sort_students(subject or '平均分')
        elif choice == '4':
            system.analyze_scores()
        elif choice == '5':
            system.class_performance()
        elif choice == '6':
            system.reverse_order()
        elif choice == '7':
            subject = input("请选择科目(高数/英语/Python/平均分): ").strip()
            system.find_top_students(subject or '平均分')
        elif choice == '8':
            name = input("请输入学生姓名(或部分): ")
            system.search_by_name(name)
        elif choice == '9':
            student_id = input("请输入学号: ")
            system.search_by_id(student_id)
        elif choice == '10':
            class_name = input("请输入班级(或部分): ")
            system.search_by_class(class_name)
        elif choice == '11':
            pos = input("请输入插入位置: ")
            info = input("请输入学生信息(学号 姓名 班级 高数 英语 Python): ").split()
            if len(info) == 6:
                try:
                    student_info = [
                        info[0],
                        info[1],
                        info[2],
                        float(info[3]),
                        float(info[4]),
                        float(info[5])
                    ]
                    system.insert_student(pos, student_info)
                except ValueError:
                    print("成绩格式错误！")
            else:
                print("输入格式错误！需要6个字段")
        elif choice == '12':
            student_id = input("请输入要删除学生的学号: ")
            system.delete_student(student_id)
        elif choice == '13':
            system.remove_duplicates()
        elif choice == '14':
            system.calculate_class_average()
        else:
            print("无效选择，请重新输入！")


# 程序入口
if __name__ == "__main__":
    main_menu()

链表实现

点击查看代码

class StudentNode:
    """学生节点"""

    def __init__(self, data=None):
        # 数据格式: [学号, 姓名, 班级, 高数, 英语, Python]
        self.data = data
        self.next = None


class StudentLinkedList:
    """基于链表实现的增强版学生管理系统"""

    def __init__(self):
        self.head = StudentNode()  # 头节点
        self.count = 0  # 学生数量计数器

    def input_students(self):
        """批量输入学生信息"""
        print("请输入学生信息(学号 姓名 班级 高数成绩 英语成绩 Python成绩)，每行一个，输入'0'结束：")
        print("示例: 2023001 张三 计算机1班 85 92 88")
        while True:
            info = input().strip()
            if info == '0':
                break
            try:
                parts = info.split()
                if len(parts) != 6:
                    print("输入格式错误！请提供6个值：学号 姓名 班级 高数成绩 英语成绩 Python成绩")
                    continue

                # 提取各部分信息
                student_id, name, class_name, math, english, python = parts
                student_info = [
                    student_id,
                    name,
                    class_name,
                    float(math),
                    float(english),
                    float(python)
                ]
                self.add_student(student_info)
            except ValueError:
                print("成绩格式错误！请确保成绩为数字")

    def add_student(self, student_info):
        """添加单个学生(尾插法)"""
        new_node = StudentNode(student_info)
        current = self.head

        # 找到链表尾部
        while current.next:
            current = current.next

        current.next = new_node
        self.count += 1
        print(f"成功添加学生: {student_info[1]} ({student_info[0]})")

    def get_student_count(self):
        """获取学生数量"""
        return self.count

    def display_students(self):
        """显示所有学生信息"""
        if self.count == 0:
            print("无学生记录")
            return

        # 格式化表头
        header = "{:<10}{:<8}{:<12}{:<8}{:<8}{:<10}{:<10}".format(
            "学号", "姓名", "班级", "高数", "英语", "Python", "平均分"
        )
        print("\n" + header)
        print("-" * len(header))

        # 遍历链表并显示信息
        current = self.head.next
        while current:
            student = current.data
            # 计算平均分
            avg_score = round((student[3] + student[4] + student[5]) / 3, 1)
            # 格式化行
            row = "{:<10}{:<8}{:<12}{:<8.1f}{:<8.1f}{:<10.1f}{:<10.1f}".format(
                student[0], student[1], student[2],
                student[3], student[4], student[5], avg_score
            )
            print(row)
            current = current.next

        print("-" * len(header))
        print(f"总计: {self.count}名学生\n")

    def sort_students(self, subject='平均分'):
        """按指定科目成绩降序排序"""
        if self.count == 0:
            print("无学生记录")
            return

        # 确定排序键
        subject_index_map = {
            '高数': 3,
            '英语': 4,
            'Python': 5,
            '平均分': -1  # 特殊处理
        }

        if subject not in subject_index_map:
            print(f"无效科目: {subject}，按平均分排序")
            subject = '平均分'

        # 将链表转换为列表以便排序
        students_list = []
        current = self.head.next
        while current:
            students_list.append(current.data)
            current = current.next

        # 如果是按平均分排序，需要计算平均值
        if subject == '平均分':
            students_list.sort(key=lambda s: (s[3] + s[4] + s[5]) / 3, reverse=True)
        else:
            index = subject_index_map[subject]
            students_list.sort(key=lambda s: s[index], reverse=True)

        # 重建链表
        self.head.next = None
        self.count = 0
        for student in students_list:
            self.add_student(student)

        print(f"已按{subject}成绩降序排序")
        self.display_students()

    def analyze_scores(self):
        """各科成绩分析"""
        if self.count == 0:
            print("无学生记录")
            return

        # 初始化各科成绩列表
        math_scores = []
        english_scores = []
        python_scores = []

        # 遍历链表收集成绩
        current = self.head.next
        while current:
            student = current.data
            math_scores.append(student[3])
            english_scores.append(student[4])
            python_scores.append(student[5])
            current = current.next

        # 科目列表
        subjects = ['高数', '英语', 'Python']
        score_lists = [math_scores, english_scores, python_scores]

        # 表头
        print("\n{:<10}{:<10}{:<10}{:<10}{:<10}".format(
            "科目", "平均分", "最高分", "最低分", "及格率"
        ))
        print("-" * 50)

        # 计算并显示各科数据
        for subj, scores in zip(subjects, score_lists):
            avg = sum(scores) / len(scores)
            max_score = max(scores)
            min_score = min(scores)
            pass_rate = sum(1 for score in scores if score >= 60) / len(scores)

            print("{:<10}{:<10.1f}{:<10.1f}{:<10.1f}{:<10.1%}".format(
                subj, avg, max_score, min_score, pass_rate
            ))

        print("-" * 50)

    def class_performance(self):
        """班级表现分析"""
        if self.count == 0:
            print("无学生记录")
            return

        # 按班级分组
        class_data = {}
        current = self.head.next
        while current:
            student = current.data
            class_name = student[2]
            if class_name not in class_data:
                class_data[class_name] = {
                    'students': [],
                    'math_scores': [],
                    'english_scores': [],
                    'python_scores': [],
                    'avg_scores': []
                }

            class_data[class_name]['students'].append(student)
            class_data[class_name]['math_scores'].append(student[3])
            class_data[class_name]['english_scores'].append(student[4])
            class_data[class_name]['python_scores'].append(student[5])
            class_data[class_name]['avg_scores'].append((student[3] + student[4] + student[5]) / 3)
            current = current.next

        # 表头
        header = "{:<12}{:<8}{:<10}{:<10}{:<10}{:<10}".format(
            "班级", "人数", "高数均分", "英语均分", "Python均分", "总分均分"
        )
        print("\n" + header)
        print("-" * len(header))

        # 计算并显示各班级数据
        for class_name, data in class_data.items():
            math_avg = sum(data['math_scores']) / len(data['math_scores'])
            eng_avg = sum(data['english_scores']) / len(data['english_scores'])
            py_avg = sum(data['python_scores']) / len(data['python_scores'])
            total_avg = sum(data['avg_scores']) / len(data['avg_scores'])

            print("{:<12}{:<8}{:<10.1f}{:<10.1f}{:<10.1f}{:<10.1f}".format(
                class_name, len(data['students']), math_avg, eng_avg, py_avg, total_avg
            ))

        print("-" * len(header))

    def reverse_order(self):
        """反转学生顺序"""
        if self.count <= 1:
            print("学生顺序已逆序" if self.count == 1 else "无学生记录")
            return

        prev = None
        current = self.head.next

        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node

        self.head.next = prev
        print("学生顺序已逆序")
        self.display_students()

    def find_top_students(self, subject='平均分'):
        """查找指定科目最高分学生"""
        if self.count == 0:
            print("无学生记录")
            return

        # 确定查找科目
        subject_index_map = {
            '高数': 3,
            '英语': 4,
            'Python': 5,
            '平均分': -1
        }

        if subject not in subject_index_map:
            print(f"无效科目: {subject}，按平均分查找")
            subject = '平均分'

        # 遍历链表查找最高分
        max_score = 0
        current = self.head.next
        while current:
            student = current.data
            if subject == '平均分':
                score = (student[3] + student[4] + student[5]) / 3
            else:
                index = subject_index_map[subject]
                score = student[index]

            if score > max_score:
                max_score = score
            current = current.next

        # 收集所有获得最高分的学生
        top_students = []
        current = self.head.next
        while current:
            student = current.data
            if subject == '平均分':
                score = (student[3] + student[4] + student[5]) / 3
            else:
                index = subject_index_map[subject]
                score = student[index]

            if abs(score - max_score) < 0.001:  # 浮点数容差比较
                top_students.append(student)
            current = current.next

        print(f"\n{subject}最高分: {max_score:.1f}, 共{len(top_students)}人:")
        self._display_students(top_students)

    def search_by_name(self, name):
        """按姓名搜索"""
        if self.count == 0:
            print("无学生记录")
            return

        results = []
        current = self.head.next
        while current:
            student = current.data
            if name.lower() in student[1].lower():
                results.append(student)
            current = current.next

        if not results:
            print(f"未找到包含'{name}'的学生")
            return

        print(f"找到{len(results)}名学生:")
        self._display_students(results)

    def search_by_id(self, student_id):
        """按学号搜索"""
        if self.count == 0:
            print("无学生记录")
            return

        results = []
        current = self.head.next
        while current:
            student = current.data
            if student[0] == student_id:
                results.append(student)
            current = current.next

        if not results:
            print(f"未找到学号为'{student_id}'的学生")
            return

        print(f"找到学号为'{student_id}'的学生:")
        self._display_students(results)

    def search_by_class(self, class_name):
        """按班级搜索"""
        if self.count == 0:
            print("无学生记录")
            return

        results = []
        current = self.head.next
        while current:
            student = current.data
            if class_name.lower() in student[2].lower():
                results.append(student)
            current = current.next

        if not results:
            print(f"未找到班级包含'{class_name}'的学生")
            return

        print(f"找到班级包含'{class_name}'的{len(results)}名学生:")
        self._display_students(results)

    def _display_students(self, students):
        """显示指定的学生列表"""
        if not students:
            return

        # 格式化表头
        header = "{:<10}{:<8}{:<12}{:<8}{:<8}{:<10}{:<10}".format(
            "学号", "姓名", "班级", "高数", "英语", "Python", "平均分"
        )
        print("\n" + header)
        print("-" * len(header))

        # 显示每个学生的信息
        for student in students:
            # 计算平均分
            avg_score = round((student[3] + student[4] + student[5]) / 3, 1)
            # 格式化行
            row = "{:<10}{:<8}{:<12}{:<8.1f}{:<8.1f}{:<10.1f}{:<10.1f}".format(
                student[0], student[1], student[2],
                student[3], student[4], student[5], avg_score
            )
            print(row)

        print("-" * len(header))

    def insert_student(self, pos, student_info):
        """在指定位置插入学生"""
        try:
            pos = int(pos)
            if pos < 1 or pos > self.count + 1:
                print("位置无效！")
                return

            # 创建新节点
            new_node = StudentNode(student_info)

            # 找到插入位置的前一个节点
            prev = self.head
            current_pos = 1

            # 移动到插入位置的前一个节点
            while current_pos < pos:
                prev = prev.next
                current_pos += 1

            # 插入新节点
            new_node.next = prev.next
            prev.next = new_node
            self.count += 1

            print(f"成功在位置{pos}插入学生: {student_info[1]}")
            self.display_students()
        except ValueError:
            print("请输入有效数字！")

    def delete_student(self, student_id):
        """按学号删除学生"""
        if self.count == 0:
            print("无学生记录")
            return

        prev = self.head
        current = self.head.next
        deleted = False

        while current:
            if current.data[0] == student_id:
                prev.next = current.next
                self.count -= 1
                deleted = True
                print(f"已删除学号为 '{student_id}' 的学生: {current.data[1]}")
                self.display_students()
                return
            prev = current
            current = current.next

        if not deleted:
            print(f"未找到学号为 '{student_id}' 的学生")

    def remove_duplicates(self):
        """按学号去重"""
        if self.count == 0:
            print("无学生记录")
            return

        # 用于跟踪已经出现过的学号
        seen_ids = set()

        prev = self.head
        current = self.head.next
        removed_count = 0

        while current:
            student_id = current.data[0]
            if student_id in seen_ids:
                # 发现重复，删除当前节点
                prev.next = current.next
                current = current.next
                removed_count += 1
                self.count -= 1
            else:
                # 新学号，添加到已见集合并继续遍历
                seen_ids.add(student_id)
                prev = current
                current = current.next

        print(f"已移除{removed_count}名重复学生")
        self.display_students()

    def calculate_class_average(self):
        """计算各班级平均分"""
        if self.count == 0:
            print("无学生记录")
            return

        # 按班级分组
        class_data = {}
        current = self.head.next
        while current:
            student = current.data
            class_name = student[2]
            if class_name not in class_data:
                class_data[class_name] = {
                    'students': [],
                    'avg_scores': []
                }

            class_data[class_name]['students'].append(student)
            class_data[class_name]['avg_scores'].append(
                (student[3] + student[4] + student[5]) / 3
            )
            current = current.next

        # 计算总体平均分
        total_avg = 0
        current = self.head.next
        while current:
            total_avg += (current.data[3] + current.data[4] + current.data[5]) / 3
            current = current.next
        total_avg /= self.count

        # 表头
        header = "{:<12}{:<10}{:<10}{:<10}".format(
            "班级", "人数", "平均分", "状态"
        )
        print("\n" + header)
        print("-" * len(header))

        # 计算并显示各班级数据
        for class_name, data in class_data.items():
            class_avg = sum(data['avg_scores']) / len(data['avg_scores'])
            status = "超过平均水平" if class_avg > total_avg else "低于平均水平"
            if abs(class_avg - total_avg) < 0.001:
                status = "达到平均水平"

            print("{:<12}{:<10}{:<10.1f}{:<10}".format(
                class_name, len(data['students']), class_avg, status
            ))

        print("-" * len(header))
        print(f"总体平均分: {total_avg:.1f}")


# 学生系统菜单
def main_menu():
    """增强版学生管理系统主菜单(链表实现)"""
    system = StudentLinkedList()

    while True:
        print("\n" + "=" * 50)
        print("增强版学生管理系统(链表实现)")
        print("=" * 50)
        print("1. 批量输入学生")
        print("2. 显示所有学生")
        print("3. 按成绩排序")
        print("4. 各科成绩分析")
        print("5. 班级表现分析")
        print("6. 逆序学生列表")
        print("7. 查找最高分学生")
        print("8. 按姓名搜索")
        print("9. 按学号搜索")
        print("10.按班级搜索")
        print("11.插入学生")
        print("12.删除学生")
        print("13.去重(按学号)")
        print("14.班级平均分分析")
        print("0. 退出系统")
        print("=" * 50)

        choice = input("请选择操作: ")

        if choice == '0':
            print("感谢使用学生管理系统!")
            break
        elif choice == '1':
            system.input_students()
        elif choice == '2':
            system.display_students()
        elif choice == '3':
            subject = input("请选择排序科目(高数/英语/Python/平均分): ").strip()
            system.sort_students(subject or '平均分')
        elif choice == '4':
            system.analyze_scores()
        elif choice == '5':
            system.class_performance()
        elif choice == '6':
            system.reverse_order()
        elif choice == '7':
            subject = input("请选择科目(高数/英语/Python/平均分): ").strip()
            system.find_top_students(subject or '平均分')
        elif choice == '8':
            name = input("请输入学生姓名(或部分): ")
            system.search_by_name(name)
        elif choice == '9':
            student_id = input("请输入学号: ")
            system.search_by_id(student_id)
        elif choice == '10':
            class_name = input("请输入班级(或部分): ")
            system.search_by_class(class_name)
        elif choice == '11':
            pos = input("请输入插入位置: ")
            info = input("请输入学生信息(学号 姓名 班级 高数 英语 Python): ").split()
            if len(info) == 6:
                try:
                    student_info = [
                        info[0],
                        info[1],
                        info[2],
                        float(info[3]),
                        float(info[4]),
                        float(info[5])
                    ]
                    system.insert_student(pos, student_info)
                except ValueError:
                    print("成绩格式错误！")
            else:
                print("输入格式错误！需要6个字段")
        elif choice == '12':
            student_id = input("请输入要删除学生的学号: ")
            system.delete_student(student_id)
        elif choice == '13':
            system.remove_duplicates()
        elif choice == '14':
            system.calculate_class_average()
        else:
            print("无效选择，请重新输入！")


# 程序入口
if __name__ == "__main__":
    main_menu()

代码测试数据

点击查看代码

2023001 张明 计算机1班 85.5 92.0 88.5
2023002 李伟 计算机1班 78.0 86.5 92.5
2023003 王芳 计算机2班 92.5 88.0 84.5
2023004 赵晓彤 计算机2班 76.5 94.0 91.5
2023005 陈浩 软件工程1班 89.0 82.5 87.0
2023006 刘佳 软件工程1班 95.0 90.5 93.5
2023007 孙磊 软件工程2班 67.5 78.0 72.5
2023008 周敏 软件工程2班 88.5 85.0 82.5
2023009 吴强 电子信息1班 76.0 83.5 79.0
2023010 郑丽 电子信息1班 84.0 91.5 88.0
2023001 张明 计算机1班 85.5 92.0 88.5 
2023012 朱志强 电子信息2班 68.0 74.5 70.0
2023013 胡月 电子信息2班 90.5 87.0 84.5
2023014 林晓燕 人工智能1班 79.5 82.0 76.5
2023015 徐海洋 人工智能1班 88.0 92.5 94.0
2023016 高杰 人工智能2班 72.5 75.0 68.5
2023017 罗慧 人工智能2班 63.0 71.5 66.0
2023018 董天宇 网络安全1班 86.5 89.0 91.5
2023019 谢文静 网络安全1班 94.5 95.0 96.5
2023020 黄斌 网络安全2班 75.0 80.5 77.5
2023021 马琳 网络安全2班 81.5 84.0 79.0
2023022 宋阳 数据科学1班 92.0 93.5 90.5
2023023 魏紫怡 数据科学1班 69.5 73.0 75.5
2023024 彭建国 数据科学2班 87.0 83.5 90.0
2023025 杜小月 数据科学2班 83.0 79.5 86.0
0