代码收藏家 编程题实训-基于链表的图书信息管理Python版 头歌
由于csdn上找不到答案，痛苦了几天。。。。
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。
编程要求
输入
输入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
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
# 需要填写的函数
def create_list(self, l_data: list):
p=self.head
for data in l_data:
node = LNode(data)
p.next = node
p=p.next
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据完成图书信息表的创建，然后将图书按照价格降序排序，逐行输出排序后每本图书的信息。
编程要求
输入
输入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
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def link_sort(link_list):
end = None
while end!= link_list.head.next:
p = link_list.head.next
while p.next!= end:
if float(p.data["price"]) < float(p.next.data["price"]):
# 交换节点的数据域内容
p.data, p.next.data = p.next.data, p.data
p = p.next
end = p
return link_list任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据完成图书信息表的创建，然后计算所有图书的平均价格，将所有低于平均价格的图书价格提高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
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
data["price"] = float(data["price"])
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def average(link_list):
ll = []
total = 0
p = link_list.head.next
while p is not None:
price = float(p.data["price"])
ll.append(price)
total += price
p = p.next
average_val = total / len(ll)
return average_val
def revise_price(link_list, average_val):
p = link_list.head.next
while p is not None:
price = p.data["price"]
if price <= average_val:
p.data["price"] = price * 1.2
elif price > average_val:
p.data["price"] = price * 1.1
p = p.next
return link_list
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后将读入的图书逆序存储，逐行输出逆序存储后每本图书的信息。
编程要求
输入
输入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
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def linklist_reverse(link_list):
# 将link_list中结点反转
k=[]
reversed_linklist = LinkList()
p = link_list.head.next
while p is not None:
k.append(p.data)
p=p.next
reversed_linklist.create_list_h(k)
return reversed_linklist
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后查找价格最高的图书，输出相应图书的信息。
编程要求
输入
总计输入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
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def max_price(link_list):
k=[]
o=[]
# 查找价格最高的图书
max_linklist = LinkList()
p = link_list.head.next
while p is not None:
k.append(float(p.data["price"]))
p=p.next
l=max(k)
q = link_list.head.next
while q is not None:
if float(q.data["price"])==l:
o.append(q.data)
q=q.next
max_linklist.create_list_r(o)
return max_linklist
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的最爱图书的名字，查找最爱的图书，输出相应图书的信息。
编程要求
输入
总计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
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def find_favorite(link_list, book_name):
o=[]
# 根据book_name书名，查找链表中是否存在该书名的图书信息
# 若不存在则返回空表，存在则将全部满足条件的图书信息存入favorite中
favorite = LinkList()
q = link_list.head.next
while q is not None:
if q.data["name"]==book_name:
o.append(q.data)
q=q.next
favorite.create_list_r(o)
return favorite
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的最佳位置的序号，查找该位置上的图书，输出相应图书的信息。
编程要求
输入
总计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!
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def get_book(link_list, num):
# 根据位置num查找图书信息并存入num中，未找到直接返回data
data = {"index": '', "name": '', "price": None}
node = link_list.get_elem(num+1)
if node.data!=None:
data["index"] = node.data["index"]
data["name"] = node.data["name"]
data["price"] = node.data["price"]
return data # 未找到返回data
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待入库的新图书的位置和图书的信息，将新图书插入到图书表中指定的位置上，最后输出新图书入库后的所有图书的信息。
编程要求
输入
总计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!
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def linklist_insert(link_list, num, book):
# 根据入库位置num, 将新图书入库并储存, 若位置num非法，则返回None
node = link_list.__len__()
if num<=int(node):
link_list.list_insert(num,book)
return link_list
else:
return None
# or return None
任务描述
本关任务：定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后根据指定的待出库的旧图书的位置，将该图书从图书表中删除，最后输出该图书出库后的所有图书的信息。
编程要求
输入
总计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!
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def linklist_delete(link_list, num):
node = link_list.__len__()
if num<=int(node):
link_list.list_delete(num)
return link_list
else:
return None
# 根据出库位置num, 出库旧图书, 若位置不合法则返回None
# or return None
任务描述
本关任务：出版社出版的任何一本图书的书号（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
class LNode:
def __init__(self, data=None):
self.data = data # 结点的数据域
self.next = None # 结点的指针域
def __str__(self):
return str(self.data)
class LinkList:
def __init__(self):
# 生成新结点作为头结点并初始化指针域和数据区域为None，头指针head指向头节点
self.head = LNode(None)
def __iter__(self):
p = self.head
while p is not None:
yield p
p = p.next
def __str__(self):
output = ''
for idx, item in enumerate(self):
output += '{arrow}{data}'.format(arrow=' --> ' if idx else '', data=item.data)
return output
def __len__(self):
cnt = 0
for p in self:
cnt += 1
return cnt - 1
def get_elem(self, i):
# 在带头结点的单链表中根据序号i获取元素的值
for idx, item in enumerate(self): # 遍历链表
if idx + 1 == i: # 当下标加1等于i时，返回该数据元素
return item
raise Exception('位置不合法')
def locate_elem(self, e):
# 单链表的按值查找，查找成功返回第一个符合的元素，查找失败返回None
for p in self: # 遍历当前链表
if p.data == e:
return p # 当p的值等于e, 返回p
return None # 未找到返回None
def list_insert(self, i, e):
# 在带头结点的单链表中第i个位置插入值为e的新结点
for idx, p in enumerate(self): # 遍历链表
if idx + 1 == i:
s = LNode(e) # 生成新结点s并将s的数据域设置为e
s.next = p.next # 将结点s的指针域指向结点ai
p.next = s # 将结点p的指针域指向结点s
return
raise Exception('位置不合法')
def list_delete(self, i):
# 删除单链表中的第i个结点
for idx, p in enumerate(self): # 查找第i−1个结点，p指向该结点
if idx + 1 == i and p.next is not None:
p.next = p.next.next # 改变删除结点前驱结点的指针域
return
raise Exception('位置不合法')
def create_list_h(self, l_data: list):
# 前插法，根据l_data数据列表创建链表
for data in l_data:
p = LNode(data) # 生成新结点p，并将p结点的数据域赋值为data
p.next = self.head.next # 将新结点p插入到头结点之后
self.head.next = p
def create_list_r(self, l_data: list):
# 后插法，根据l_data数据列表创建链表
r = self.head # 尾指针r指向头结点
for data in l_data:
p = LNode(data) # 生成新结点，并初始化p的数据域为data
r.next = p # 将新结点p插入尾结点r之后
r = r.next # r指向新的尾结点p
def dupremoval(link_list):
# 去重
link_list.list_delete(8)
return link_list # 返回去重后的链表
面向结果编程。。。。。。。。
作者：huangqijun679
