用类，查找，排序等数据结构(Python)，实现关于外
卖平台的菜品信息管理
输入菜品的名称就能输出菜品的价格等菜品信息，可
以增删排序菜品。
数据量有上百个
可以使用Python中的类来实现菜品信息管理，并使用查找和排序等数据结构来增强功能。以下是一个简单的实现示例：
```python
class Dishes:
def __init__(self, name, price, calories, protein, carbs, fat):
self.name = name
self.price = price
self.calories = calories
self.protein = protein
self.carbs = carbs
self.fat = fat
def __str__(self):
return f"{self.name} - 价格：{self.price}, 热量：{self.calories}, 蛋白质：{self.protein}, 碳水化合物：{self.carbs}, 脂肪：{self.fat}"
def search_dish(name):
for dish in dishes:
if dish.name == name:
return dish
return None
def add_dish(name, price, calories, protein, carbs, fat):
dish = Dishes(name, price, calories, protein, carbs, fat)
dishes.append(dish)
print(f"成功添加菜品：{name}")
def delete_dish(name):
dish = search_dish(name)
if dish is not None:
dishes.remove(dish)
print(f"成功删除菜品：{name}")
else:
print("未找到菜品：{name}")
def print_dishes():
print("所有菜品列表：")
for dish in dishes:
print(dish)
dishes = []
while True:
print("\n请选择操作：")
print("1. 查看所有菜品")
print("2. 添加菜品")
print("3. 删除菜品")
print("4. 查找菜品")
print("5. 退出程序")
choice = input("请输入操作编号：")
if choice == '1':
print_dishes()
elif choice == '2':
name = input("请输入菜品名称：")
price = input("请输入菜品价格：")
calories = input("请输入菜品热量：")
protein = input("请输入菜品蛋白质含量：")
carbs = input("请输入菜品碳水化合物含量：")
fat = input("请输入菜品脂肪含量：")
add_dish(name, price, calories, protein, carbs, fat)
elif choice == '3':
name = input("请输入要删除的菜品名称：")
delete_dish(name)
elif choice == '4':
name = input("请输入要查找的菜品名称：")
dish = search_dish(name)
if dish is not None:
print(dish)
else:
print("未找到菜品：{name}")
elif choice == '5':
print("程序已退出。")
break
else:
print("输入错误，请重新输入。")
```
#功能:
实现单链表的构建和功能操作
#定义单链表的类
class Node:
"""
思路:将自定义的类视为节点的生成类,实例对象中
包含数据部分和指向下一个节点的next
"""
def __init__(self, val, next=None):
self.val = val # 有用数据
self.next = next # 循环链接下一个节点关系
#单链表的操作逻辑
class LinkList:
"""
思想:单链表类,生成对象可以进行增删改查操作
"""
# 创建数据为空的一个链表头
def __init__(self):
"""
初始化链表,标记一个链表的开端,以便于获取后续的节点
:param val:
"""
self.head = Node(None)
# 通过list_为链表添加一组节点
def init_list(self, list_):
p = self.head # p作为移动变量
for item in list_:
p.next = Node(item)
p = p.next
# 遍历列表
def show(self):
p = self.head.next # 第一个有效节点
while p is not None:
print(p.val)
p = p.next # p向后移动
# 判断链表为空
def is_emply(self):
if self.head.next is None: # head后面一个节点没有,判断为空
return True
else:
return False
# 清空链表
def clear_list(self):
self.head.next = None
# 索引列表(读取指定列表元素)
def index_variables(self, index_):
p = self.head
for item in range(index_ + 1):
if p.next == None:
# 超出位置最大范围跳出循环,提示错误
raise IndexError("list index out of range")
p = p.next
return p.val
# 尾部插入
def append(self, val):
p = self.head
while p.next is not None:
p = p.next
p.next = Node(val)
# 头部插入
def head_insert(self, val):
node = Node(val)
node.next = self.head.next
self.head.next = node
# 索引插入(指定位置插入)
def index_insert(self, index_, val):
p = self.head
for item in range(index_):
if p.next == None:
# 超出位置最大范围跳出循环
break
p = p.next
node = Node(val)
node.next = p.next
p.next = node
# 删除指定数据的节点
def delete_val(self, val):
p = self.head
# 结束循环必然两个条件其一为假
while p.next and p.next.val != val:
p = p.next
if p.next is None:
print("x not in linklist")
else:
p.next = p.next.next
# 删除指定位置节点
def delete_index(self, index_):
p = self.head
for item in range(index_):
if p.next == None:
# 超出位置最大范围跳出循环
break
p = p.next
if p.next == None:
pass # 超出最大位置不删除
else:
p.next = p.next.next
#有序链表(从小到大)中插入单个节点,保证链表依然有序
def index_val(self,val):
p = self.head
while p.next!=None and p.next.val<val:
p=p.next
node = Node(val)
node.next = p.next
p.next = node
#节点数据从小到大排序
def up_list(self):
"""
将链表数据从小到大排列
:return:
"""
p=self.head
l_re=LinkList()#新建一个链表，用来从小到大存放节点
while p.next != None:
l_re.index_val(p.next.val) # 加第一个
p=p.next# 删第一个
self.head=l_re.head
#测试函数
if __name__=="__main__":
"""
测试函数
:return:
"""
l = LinkList() # 新建一个链表头
l.head.next = Node(1)
print(l.head.next.val)
print("------------------------")
l.init_list([9,7,5,3,1]) # 插入列表
l.append(11) # 尾部插入
l.head_insert(66) # 头部插入
l.index_insert(3, 77) # 指定位置插入
l.index_insert(20, 13) # 超出位置插入最后
l.index_insert(-20, 11) # 插入在开头
l.delete_val(77) # 删除指定数据节点(只删除第一个出现的)
l.delete_index(1) # 删除指定位置节点
l.delete_index(-100) # 删除开头元素
l.delete_index(10) # 超出最大位置不删除
l.index_val(4)#有序链表(从小到大)中插入单个节点,保证链表依然有序
l.up_list() #链表 数据节点从小到大排序
l.show()#遍历链表
l.index_variables(0)
针对该问题，我们可以选择使用列表(list)作为数据结构，其中每个元素表示一个菜品的信息，包括名称、价格、销量等。可以考虑将每个菜品信息设计为一个字典(dict)。
以下是实现增加、删除和排序功能的代码示例：
# 初始化菜品列表，每个元素为一个字典
dishes = [
{'name': '麻辣香锅', 'price': 38, 'sales': 500},
{'name': '宫保鸡丁', 'price': 25, 'sales': 300},
{'name': '土豆丝', 'price': 12, 'sales': 200},
]
# 增加菜品
def add_dish(dish):
dishes.append(dish)
# 删除菜品
def delete_dish(name):
for dish in dishes:
if dish['name'] == name:
dishes.remove(dish)
# 按价格排序，从低到高
def sort_by_price_asc():
return sorted(dishes, key=lambda x: x['price'])
# 按销量排序，从高到低
def sort_by_sales_desc():
return sorted(dishes, key=lambda x: x['sales'], reverse=True)
这些函数调用时可以按需求组合使用，例如增加一道菜品：
add_dish({'name': '拍黄瓜', 'price': 10, 'sales': 100})
删除一道菜品：
delete_dish('土豆丝')
按价格排序：
dishes_sorted = sort_by_price_asc()
按销量排序：
dishes_sorted = sort_by_sales_desc()
由于菜品数量较多，当数据量过大时，可以考虑使用堆数据结构来实现排序操作，以减少时间复杂度。以大根堆为例，可以先将原始列表(heap)中的元素逐个插入堆中，再一个一个弹出，即可得到按价格从高到低/销量从低到高排序的结果。
以下是使用heapq模块实现堆排序的代码示例：
import heapq
# 初始化菜品列表，每个元素为一个字典
dishes = [
{'name': '麻辣香锅', 'price': 38, 'sales': 500},
{'name': '宫保鸡丁', 'price': 25, 'sales': 300},
{'name': '土豆丝', 'price': 12, 'sales': 200},
]
# 将每个元素转化为二元组（如(38, {'name': '麻辣香锅', 'price': 38, 'sales': 500})），并插入堆中
# 以价格为基准，构建大根堆
heap = []
for dish in dishes:
heapq.heappush(heap, (-dish['price'], dish))
# 弹出堆顶元素，即最大值
while heap:
print(heapq.heappop(heap)[1])
按销量从低到高排序的代码类似，只需将元组中的第一个元素改为字典中的’sales’字段即可。
希望这些能够帮助您解决问题！
要实现一个外卖平台菜品信息管理程序，需要使用以下数据结构：
列表：用于存储菜品信息，每个菜品信息可以包括菜品名称、价格、销量等字段。
字典：用于存储列表中每个菜品的ID和对应的信息，以便快速查找和修改菜品信息。
类：创建一个类来表示菜品，包括菜品名称、价格、销量等属性，以及排序等方法。
输入：从用户输入中获取菜品名称，并查找该菜品信息。
输出：将菜品信息输出到屏幕上，包括菜品名称、价格、销量等信息。
排序：使用Python内置的排序函数或自定义排序方法，对菜品列表进行排序。
增删排序：使用Python内置的列表方法或自定义方法，实现对菜品信息的增加、删除和修改操作。
下面是一个简单的Python代码示例，实现了上述功能：
# 定义菜品类
class Dish:
def __init__(self, name, price):
self.name = name
self.price = price
self.sales = 0
def display(self):
print(f"Name: {self.name}, Price: {self.price}, Sales: {self.sales}")
# 创建菜品列表和字典
dishes = []
dishes_dict = {}
# 输入菜品信息
while True:
name = input("Enter dish name (or 'q' to quit): ")
if name == 'q':
break
price = float(input("Enter dish price: "))
dish = Dish(name, price)
dishes.append(dish)
dishes_dict[name] = dish
# 输出所有菜品信息
print("All dishes:")
total_sales = 0
for dish in dishes:
dish.display()
total_sales += dish.sales
print(f"Total sales: {total_sales}")
# 查找菜品信息
dish_name = input("Enter dish name to view: ")
if dish_name in dishes_dict:
dish = dishes_dict[dish_name]
dish.display()
else:
print("Dish not found.")
# 排序菜品列表
print("Sorted dishes:")
sorted_dishes = sorted(dishes, key=lambda x: x.price)
for dish in sorted_dishes:
dish.display()
total_sales += dish.sales
print(f"Total sales: {total_sales}")
# 增删排序菜品信息
while True:
action = input("Enter action (add, delete, sort, exit): ")
if action == 'add':
name = input("Enter dish name: ")
if name in dishes_dict:
print("Dish already exists.")
else:
price = float(input("Enter dish price: "))
dish = Dish(name, price)
dishes.append(dish)
dishes_dict[name] = dish
print(f"Dish added. Total dishes: {len(dishes)}")
elif action == 'delete':
name = input("Enter dish name: ")
if name not in dishes_dict:
print("Dish not found.")
else:
dishes.remove(dishes_dict[name])
del dishes_dict[name]
print(f"Dish deleted. Total dishes: {len(dishes)}")
elif action == 'sort':
sorted_dishes = sorted(dishes, key=lambda x: x.price)
for dish in sorted_dishes:
dish.display()
total_sales = sum([dish.sales for dish in sorted_dishes])
print(f"Total sales: {total_sales}")
elif action == 'exit':
break
else:
print("Invalid action.")```