编程题实训-基于顺序表的图书信息管理Python版

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

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(i+1,data[i])
    return sq_list 

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

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关：基于顺序存储结构的图书信息表的修改

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
    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 round(average,2) , sq_list
    

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

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 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

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

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_insert(sq_list, pos, book):
    # 在pos处插入book
    # 返回插入后的sq_list, 若插入位置不合法，返回None
    if pos < 1 or pos > sq_list.length:
        return None
    sq_list.list_insert(pos, book)
    # 返回插入后的sq_list, 若插入位置不合法，返回None
    return sq_list
    pass

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

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 delete_sq(sq_list, pos):
    # 旧图书的出库和输出
    if pos <1or pos >sq_list.length:
        return None
    # 返回删除pos位置图书后的sq_list, 若pos不合法，返回None
    sq_list.list_delete(pos)
    return sq_list
    pass