第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
