快速排序
快速排序的平均时间复杂度是（最好的情况下的时间复杂度是），最坏的情况下，可退化成（少见）
原创...小于 1 分钟
菜单排序
假设你是一家餐厅的老板，你有一份包含所有菜品名称及其价格的列表。你需要编写一个程序来按照价格对这些菜品进行快速排序，以便能够快速找到最贵和最便宜的菜品。
menu = [("牛排", 99), ("沙拉", 49), ("汤", 29), ("甜点", 59)]
quick_sort_menu(menu, 0, len(menu)-1)
print("价格排序后的菜单:", menu)
# 价格排序后的菜单: [('汤', 29), ('沙拉', 49), ('甜点', 59), ('牛排', 99)]
原创...大约 3 分钟
冒泡排序
冒泡排序的时间复杂度是（最好的情况下的时间复杂度是），空间复杂度是
原创...大约 3 分钟
堆排序
-
堆排序是通过
完全二叉树实现的 -
堆排序的时间复杂度在所有情况下都是
O(nlogn) -
不稳定的算法
堆
堆是一种数据结构，它是一种特殊的完全二叉树，如果这个堆是一个大顶堆（最大元素在堆顶），那么每个节点上的元素都应该比它子节点上的元素大，最大的元素在根节点上。
__
编号
从根节点开始，每一层从左到右依次编号。将每个元素放到放到同一数组里
原创...大约 1 分钟
原创...小于 1 分钟
Please wait for some time! 敬请期待
原创...小于 1 分钟
1. 有效的括号（简单）
题目描述：
给定一个只包括 '('，')'，'{'，'}'，'[' 和 ']' 的字符串，判断字符串是否有效。有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
- 注意空字符串可被认为是有效字符串。
示例：
原创...大约 1 分钟
队列
遵循先进先出FIFO（first in first out）的原则。在这种结构中，数据被依次添加到队列末端，并从队列的前端移除。类似于结账排队。
操作
队列主要支持以下几种操作
- Enqueue：将一个元素添加到队列的尾部
- Dequeue：从队列头部移除一个元素
- Front：获取头部元素（不移除）
- IsEmpty：检查队列是否为空
- Size：返回队列中元素的数量
实现
原创...大约 3 分钟
二叉树
- 根节点
- 子节点
- 父节点
- 叶节点：没有子节点的节点
- 深度：从根到特定节点的“边”的数量
遍历
- 前序遍历：先访问跟节点，递归地访问遍历左子树，再同样遍历右子树
- 中序遍历：先递归地遍历左子树，再访问根节点，最后遍历右子树
- 后序遍历：先左，再右，后根
class TreeNode:
def __init__(self, key):
self.left = None
self.right = None
self.val = key
class BinaryTree:
def __init__(self):
self.root = None
def insert(self, key):
if self.root is None:
self.root = TreeNode(key)
else:
self._insert(self.root, key)
def _insert(self, root, key):
if key < root.val:
if root.left is None:
root.left = TreeNode(key)
else:
self._insert(root.left, key)
else:
if root.right is None:
root.right = TreeNode(key)
else:
self._insert(root.right, key)
def search(self, key):
return self._search(self.root, key)
def _search(self, root, key):
if root is None or root.val == key:
return root
if key < root.val:
return self._search(root.left, key)
return self._search(root.right, key)
def inorder(self):
return self._inorder(self.root, [])
def _inorder(self, root, result):
if root:
self._inorder(root.left, result)
result.append(root.val)
self._inorder(root.right, result)
return result
def preorder(self):
return self._preorder(self.root, [])
def _preorder(self, root, result):
if root:
result.append(root.val)
self._preorder(root.left, result)
self._preorder(root.right, result)
return result
def postorder(self):
return self._postorder(self.root, [])
def _postorder(self, root, result):
if root:
self._postorder(root.left, result)
self._postorder(root.right, result)
result.append(root.val)
return result
# 示例使用
if __name__ == "__main__":
tree = BinaryTree()
elements = [20, 10, 30, 5, 15, 25, 35]
for elem in elements:
tree._insert(elem)
print("Inorder traversal:", tree.inorder())
print("Preorder traversal:", tree.preorder())
print("Postorder traversal:", tree.postorder())
key = 15
node = tree.search(key)
if node:
print(f"Found node with key {key}")
else:
print(f"Node with key {key} not found")
原创...大约 6 分钟