基于顺序表的图书信息管理Python版

已于 2024-10-11 23:05:31 修改
阅读量1.5k 收藏 24
点赞数 23
分类专栏： 头歌实践教学平台 文章标签： python 数据结构 算法 链表
于 2024-10-09 08:55:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aa050417/article/details/142774139
版权

第1关：基于顺序存储结构的图书信息表的创建和输出

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。

编程要求


输入


输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。

输出


总计n+1行，第1行是所创建的图书表中的图书个数，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数。

测试说明


平台会对你编写的代码进行测试：

测试输入：
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
0 0 0
预期输出：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00

来源


  https://www.bjfuacm.com/

开始你的任务吧，祝你成功！

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])


#第一关
def sq_create(data):
    # 顺序表的初始化
    sq_list = SqList()
    for i in range (len(data)):
        sq_list.list_insert(sq_list.length + 1, {
            "index":data[i]["index"],
            "name":data[i]["name"],
            "price":float(data[i]["price"])
        })
    return sq_list

第2关：基于顺序存储结构的图书信息表的排序

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据完成图书信息表的创建，然后将图书按照价格降序排序，逐行输出排序后每本图书的信息。

编程要求


输入


输入n+1行，前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。

输出


总计n行，每行是一本图书的信息（书号、书名、价格），书号、书名、价格用空格分隔。其中价格输出保留两位小数。

测试说明


平台会对你编写的代码进行测试：

测试输入：
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
0 0 0
预期输出：
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787302164340 Operating-System 50.00
9787822234110 The-C-Programming-Language 38.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257646 Data-Structure 35.00
9787302219972 Software-Engineer 32.00

开始你的任务吧，祝你成功！

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])

# 第二关
def sq_sort(sq_list):
    # 排序
    for i in range(1, sq_list.length):
        for j in range(sq_list.length - i):
            if sq_list.elem[j]["price"] < sq_list.elem[j+1]["price"]:
                sq_list.elem[j],sq_list.elem[j+1] = sq_list.elem[j+1],sq_list.elem[j]
    return sq_list

第3关：基于顺序存储结构的图书信息表的修改

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据完成图书信息表的创建，然后计算所有图书的平均价格，将所有低于平均价格的图书价格提高20%，所有高于或等于平均价格的图书价格提高10%，最后逐行输出价格修改后的图书信息。

编程要求


输入


输入n+1行，前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。

输出


总计n+1行，第1行是修改前所有图书的平均价格，后n行是价格修改后n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数。

测试说明


平台会对你编写的代码进行测试：

测试输入：
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
0 0 0
预期输出：
43.88
9787302257646 Data-Structure 42.00
9787302164340 Operating-System 55.00
9787302219972 Software-Engineer 38.40
9787302203513 Database-Principles 43.20
9787810827430 Discrete-Mathematics 43.20
9787302257800 Data-Structure 68.20
9787811234923 Compiler-Principles 68.20
9787822234110 The-C-Programming-Language 45.60

来源
   https://www.bjfuacm.com/

开始你的任务吧，祝你成功！

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])


#第三关
def revise_price_sq(sq_list):
    # 计算平均价格，并按照题目要求修改价格
    # 返回平均价格和修改后的顺序表
    average = 0
    sum = 0
    for i in range(sq_list.length):
        sum += sq_list.elem[i]['price']
    average = sum / sq_list.length
    average = round(average,2)
    for i in range(sq_list.length):
        if sq_list.elem[i]['price'] >= average:
            sq_list.elem[i]['price'] *= 1.1
        else:
            sq_list.elem[i]['price'] *= 1.2
    return average, sq_list

第4关：基于顺序存储结构的图书信息表的逆序存储

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后将读入的图书信息逆序存储，逐行输出逆序存储后每本图书的信息。

编程要求


输入


输入n+1行，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。?

输出


总计n行，第i行是原有图书表中第n-i+1行的图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔。其中价格输出保留两位小数。

测试说明


平台会对你编写的代码进行测试：

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
预期输出：
9787822234110 The-C-Programming-Language 38.00
9787811234923 Compiler-Principles 62.00
9787302257800 Data-Structure 62.00
9787810827430 Discrete-Mathematics 36.00
9787302203513 Database-Principles 36.00
9787302219972 Software-Engineer 32.00
9787302164340 Operating-System 50.00
9787302257646 Data-Structure 35.00

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])


#第4关
def reverse_sq(sq_list):
    reversed_list = SqList()  # 创建一个新的顺序表用于存储逆序元素
    for i in range(sq_list.length - 1, -1, -1):  # 从最后一个元素到第一个元素遍历
        reversed_list.list_insert(reversed_list.length + 1, sq_list.elem[i])  # 插入到新的顺序表
    return reversed_list  # 返回逆序存储的顺序表

# 测试代码
if __name__ == "__main__":
    sq = SqList()
    n = int(input())  # 输入图书数量
    for _ in range(n):
        book_info = input().strip()  # 读取书籍信息
        sq.list_insert(sq.length + 1, book_info)  # 插入到顺序表中

    # 逆序存储并输出
    reversed_books = reverse_sq(sq)
    for i in range(len(reversed_books)):
        print(reversed_books.get_elem(i + 1))  # 逐行输出逆序的图书信息

（这题干了我一个小时，最后用了文心和gpt，不知道为什么它写了个主函数）

第5关：基于顺序存储结构的图书信息表的最贵图书的查找

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后查找价格最高的图书，输出相应图书的信息。

编程要求


输入


总计输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。

输出


总计输出m+1行，其中，第一行是最贵图书的数目（价格最高的图书可能有多本），后m行是最贵图书的信息，每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。

测试说明


平台会对你编写的代码进行测试：

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
预期输出：
2
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])

#第5关
def highest_price_sq(sq_list):
    # 查找最贵的书,放入result并返回
    max_price = 0
    for i in range(sq_list.length):
        if sq_list.elem[i]['price'] > max_price:
            max_price = sq_list.elem[i]['price']
    result = SqList()
    for i in range(sq_list.length):
        if max_price == sq_list.elem[i]['price']:
            result.list_insert(result.length + 1, sq_list.elem[i])
    return result

第6关：基于顺序存储结构的图书信息表的最爱图书的查找

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的最爱图书的名字，查找最爱的图书，输出相应图书的信息。

编程要求


输入


总计n+m+2行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。然后输入m+1行，其中，第一行是一个整数m，代表查找m次，后m行是每次待查找的最爱图书名字。

输出


若查找成功： 总计输出m*（k+1）行，对于每一次查找，第一行是最爱图书数目（同一书名的图书可能有多本），后k行是最爱图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。 若查找失败： 只输出以下提示：抱歉，没有你的最爱！

测试说明


平台会对你编写的代码进行测试：

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
2
Java-Programming-Language
Data-Structure
预期输出：
Sorry，there is no your favourite!
2
9787302257646 Data-Structure 35.00
9787302257800 Data-Structure 62.00

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])


#第6关
def find_favorite_sq(sq_list, name):
    # 返回包含最爱图书的顺序表, 待查书名name
    result = SqList()
    for i in range(len(sq_list)):
        if list(sq_list.get_elem(i+1).values())[1] == name:
            result.list_insert(result.length + 1, {
                "index": sq_list.get_elem(i+1)['index'],
                "name": sq_list.get_elem(i+1)['name'],
                "price": sq_list.get_elem(i+1)['price']})    
    return result

第7关：基于顺序存储结构的图书信息表的最佳位置图书的查找

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的最佳位置的序号，查找该位置上的图书，输出相应图书的信息。

编程要求


输入


总计n+m+2行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。然后输入m+1行，其中，第一行是一个整数m，代表查找m次，后m行每行内容为一个整数，代表待查找的图书的位置序号。

输出


输出m行 若查找成功： 输出内容为第i次查询的指定位置上的一本图书的信息（书号、书名、价格），书号、书名、价格用空格分隔，其中价格输出保留两位小数。 若查找失败： 只输出以下提示：抱歉，最佳位置上的图书不存在！

测试说明


平台会对你编写的代码进行测试：

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
2
2
0
预期输出：
9787302164340 Operating-System 50.00
Sorry，the book on the best position doesn't exist!

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])


#第7关
def find_locate_sq(sq_list, pos):
    # 查找最佳位置图书,  若找到，返回如下dict, 否则返回None
    """
    {
        "index": book index,
        "name": book name,
        "price": book price
    }
    """
    if 0 < pos <= len(sq_list):
        result = {"index": sq_list.get_elem(pos)['index'],
                "name": sq_list.get_elem(pos)['name'],
                "price": sq_list.get_elem(pos)['price']}
    else:
        result = None
    pass
    return result

第8关：基于顺序存储结构的图书信息表的新图书的入库

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待入库的新图书的位置和信息，将新图书插入到图书表中指定的位置上，最后输出新图书入库后所有图书的信息。

编程要求


输入


总计n+3行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。之后输入第n+2行，内容仅为一个整数，代表待入库的新图书的位置序号。最后输入第n+3行，内容为新图书的信息，书号、书名、价格用空格分隔。

输出


若插入成功： 输出新图书入库后所有图书的信息（书号、书名、价格），总计n+1行，每行是一本图书的信息，书号、书名、价格用空格分隔。其中价格输出保留两位小数。 若插入失败： 只输出以下提示：抱歉，入库位置非法！

测试说明


平台会对你编写的代码进行测试：

测试输入：
7
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
2
9787822234110 The-C-Programming-Language 38.00
预期输出：
9787302257646 Data-Structure 35.00
9787822234110 The-C-Programming-Language 38.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00

测试输入：
7
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9
9787822234110 The-C-Programming-Language 38.00
预期输出：
Sorry，the position to be inserted is invalid!

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])

#第8关
def sq_insert(sq_list, pos, book):
    # 在pos处插入book
    if pos < 1 or pos > sq_list.length:
        return None
    sq_list.list_insert(pos, book)
    # 返回插入后的sq_list, 若插入位置不合法，返回None
    return sq_list
    pass


第9关：基于顺序存储结构的图书信息表的旧图书的出库

任务描述


本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待出库的旧图书的位置，将该图书从图书表中删除，最后输出该图书出库后的所有图书的信息。

编程要求


输入


总计n+2行。首先输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。之后输入第n+2行，内容仅为一个整数，代表待删除的旧图书的位置序号。

输出


若删除成功： 输出旧图书出库后所有图书的信息（书号、书名、价格），总计n-1行，每行是一本图书的信息，书号、书名、价格用空格分隔。其中价格输出保留两位小数。 若删除失败： 只输出以下提示：抱歉，出库位置非法！

测试说明


平台会对你编写的代码进行测试：

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
2

预期输出：
9787302257646 Data-Structure 35.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00

测试输入：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
9
预期输出：
Sorry，the position to be deleted is invalid!

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])


#第9关
def delete_sq(sq_list, pos):
    # 旧图书的出库和输出
    if pos < 1 or pos > sq_list.length:
        return None
    # 返回删除pos位置图书后的sq_list, 若pos不合法，返回None
    sq_list.list_delete(pos)
    return sq_list
    pass

第10关：基于顺序存储结构的图书信息表的图书去重

任务描述


本关任务：出版社出版的任何一本图书的书号（ISBN）都是唯一的，即图书表中不允许包含书号重复的图书。定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建（书号可能重复），然后进行图书的去重，即删除书号重复的图书（只保留第一本），最后输出去重后所有图书的信息。

编程要求


输入


总计输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格（书号可能重复）。其中书号和书名为字符串类型，价格为浮点数类型。

输出


总计输出m+1行（m≤n），其中，第一行是去重后的图书数目，后m行是去重后图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。

测试说明


平台会对你编写的代码进行测试：

测试输入：
9
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00
预期输出：
8
9787302257646 Data-Structure 35.00
9787302164340 Operating-System 50.00
9787302219972 Software-Engineer 32.00
9787302203513 Database-Principles 36.00
9787810827430 Discrete-Mathematics 36.00
9787302257800 Data-Structure 62.00
9787811234923 Compiler-Principles 62.00
9787822234110 The-C-Programming-Language 38.00

代码

max_size = 1000


class SqList:
    def __init__(self):
        self.elem = [None] * max_size  # 为顺序表分配一个大小为max_size的数组空间
        self.length = 0  # 空表长度为0

    def list_insert(self, i, e):
        # 在顺序表中第i个位置插入新的元素e，i值的合法范围是1≤i≤L.length+1

        if i > len(self.elem):  # 存储空间已满
            raise Exception('空间已满')

        if i < 1 or i > self.length + 1:
            raise Exception('位置不合法')

        for idx in range(self.length - 1, i - 2, -1):
            self.elem[idx + 1] = self.elem[idx]  # 插入位置及之后的元素后移
        self.elem[i - 1] = e  # 将新元素e放入第i个位置
        self.length += 1  # 表长加1

    def clear_list(self):
        self.length = 0

    def list_empty(self):
        return self.length == 0

    def get_elem(self, i):
        # 返回顺序表self中的第i个元素
        if 1 <= i <= self.length:
            return self.elem[i - 1]
        raise Exception('位置不合法')

    def locate_elem(self, e):
        # 在顺序表中查找值为e的数据元素，返回其序号
        for i, elem in enumerate(self.elem[:self.length]):
            if elem == e:
                return i + 1  # 查找成功，返回序号i+1
        raise Exception('元素不存在')

    def list_delete(self, i):
        # 删除顺序表中第i个元素
        if i < 1 or i > self.length:
            raise Exception('位置不合法')
        for idx in range(i, self.length):
            self.elem[idx - 1] = self.elem[idx]  # 被删除元素之后的元素前移
        self.length -= 1  # 表长减1

    def set_length(self, a):
        self.length = a

    def __len__(self):
        return self.length

    def __str__(self):
        return str(self.elem[:self.length])


def sq_duplicate_removal(sq_list):
    # 图书去重
    for i in range(1, sq_list.length):
        for j in range(i+1,sq_list.length):
            if sq_list.elem[i]["name"] == sq_list.elem[j]["name"]:
                sq_list.list_delete(j+1)
            else:
                result = None              
    return sq_list

2024.10.11  23:05  完成所有。

编程题实训-基于顺序表的图书信息管理
Junds0的博客
04-07 1171
最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待入库的新图书的位置和信息，将新图书插入到图书表中指定的位置上，最后输出新图书入库后所有图书的信息。本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待出库的旧图书的位置，将该图书从图书表中删除，最后输出该图书出库后的所有图书的信息。其中价格输出保留两位小数。
编程题实训-基于顺序表的图书信息管理Python版
最新发布
Junds0的博客
04-11 347
任务描述 本关任务：定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。编程要求 输入 输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。输出 总计n+1行，第1行是所创建的图书表中的图书个数，后n行是n本图书的信息（书号、书名、
基于顺序存储结构的图书信息表的创建和输出 描述 定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。
qq_45456758的博客
03-09 1132
【代码】基于顺序存储结构的图书信息表的创建和输出 描述 定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。
编程题实训-基于顺序表的图书信息管理（头歌）
热门推荐
a61233的博客
10-09 1万+
第1关：基于顺序存储结构的图书信息表的创建和输出。
数据结构——基于顺序表管理图书信息
weixin_52595313的博客
10-13 2655
#include <iostream> #include<iomanip> #include<string> using namespace std; #define MAXSIZE 10000 typedef struct { string no; string name; double price; }Book; typedef struct { Book *elem; int num; }SqList; //价格处理 void Aver(SqList.
顺序表实现图书信息管理系统
qq_62175345的博客
04-13 4406
设计一个图书信息管理系统，每本图书包含ISBN号、书名、定价信息， 要求实现取值、查找、插入、删除等功能 #include <cstring> #include <iostream> #include <stdlib.h> #define ok 1 #define error 0 #define overflow -2 #define MaxSize 100 using namespace std; typedef int status; //定义 t..
基于顺序表的图书信息管理系统
TechBurst的博客
08-15 943
通过以上代码实现，我们成功构建了一个基于顺序表的图书信息管理系统。该系统具备添加、删除、查找、修改和显示图书信息的功能，并且使用了合适的数据结构和算法来支持这些操作。对于需要进行图书信息管理的机构或个人来说，这个系统将会是一个非常方便和高效的工具。通过对系统的进一步扩展和优化，可以满足更多复杂的需求，提升管理效率，为用户提供更好的服务体验。我们将详细讲解系统的设计思路、功能模块以及相应的源代码实现。为了实现上述功能需求，我们可以使用一种常见的数据结构——顺序表来存储图书信息。基于顺序表的图书信息管理系统。
第5关：基于顺序存储结构的图书信息表的最贵图书的查找
m0_63759457的博客
12-02 3285
基于顺序存储结构的图书信息表的最贵图书的查找
顺序表实现的图书管理
06-19
定义图书类型结构，定义顺序表；完成功能：初始化构建空表、插入新记录到第i个位置、删除表中第i个记录、按图书名称进行查找、按作者进行查找、按价格区间进行查找。
数据结构课程设计图书信息管理系统报告(顺序表)（模板）
09-19
使用顺序表完成的数据结构课设报告 随着计算机的广泛应用，其逐步成为现代化的标志。图书馆在正常运行过程中总是面对大量的读者信息，书籍信息以及两者相互作用产生的借书信息、还书信息。因此需要对读者资源、书籍资源、借书信息、还书信息进行管理，及时了解各个环节中信息的变更，要对因此而产生的单据进行及时的处理，为了提高图书馆或者企业内部对图书存销的自动化的管理，能够更快速的满足读者的要求，提高各种工作的效率，现对其设计相应的系统，以达到上述的目的。
数据结构 图书管理（线性表）
10-21
使用线性表实现图书管理功能，主要实现以下功能： 增加图书、删除图书、修改图书信息、查询与定位（查询方式由学生自行设计）、显示与浏览等。
基于顺序表的图书信息
12-07
基于顺序表的图书信息是一种简单的数据结构，它可以用来存储和管理图书信息。以下是基于顺序表的图书信息的实现方法： 1. 定义一个包含图书信息的类Book，包括图书编号、图书名称、作者、出版社、出版日期等信息。 ...
编程题实训-基于链表的图书信息管理
Junds0的博客
09-19 1365
然后输入m+1行，其中，第一行是一个整数m，代表查找m次，后m行每行内容为一个整数，代表待查找的图书的位置序号。本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待入库的新图书的位置和图书的信息，将新图书插入到图书表中指定的位置上，最后输出新图书入库后的所有图书的信息。总计输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格（书号可能重复）。
基于顺序表的图书管理系统
qq_43575301的博客
10-07 5884
#include #include #include #include <string.h> #define MAXSIZE 100 using namespace std; char s0[20],s1[20],s2[20],s3[20],s4[30]; int num; typedef struct //图书类型Book定义 { char no[20]; //书号 cha...
数据结构实验一，第4题：基于顺序存储结构的图书信息表的逆序存储
Cznwtl的博客
10-04 3928
描述 定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后将读入的图书信息逆序存储，逐行输出逆序存储后每本图书的信息。 输入 输入n+1行，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。其中书号和书名为字符串类型，价格为浮点数类型。 输出 总计n行，第i行是原有图书表中第...
基于顺序存储结构的图书信息表的创建和输出
qq_53136512的博客
02-09 3190
基于顺序存储结构的图书信息表的创建和输出 描述 定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。 输入 输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其中书号和书名为字符串类型，价格为浮点数类型。 输出 总计n+1行，第1行是所创建的图书表中的图书个数，后n行是n本图
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值