编程是一门实践性很强的技能，通过不断的练习和挑战，可以提升你的编程思维和解题能力。以下是一系列实战代码练习题，涵盖了不同的编程语言和算法类型，旨在帮助你解锁编程技能，挑战你的编程思维。
1. 函数和变量
题目描述： 编写一个函数，计算两个整数的和。
def add_numbers(a, b):
return a + b
# 测试代码
print(add_numbers(5, 7)) # 应输出 12
2. 排序算法
题目描述： 实现一个冒泡排序算法，对数组进行排序。
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
# 测试代码
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print(arr) # 应输出排序后的数组
3. 字符串操作
题目描述： 编写一个函数，检查一个字符串是否是回文。
def is_palindrome(s):
return s == s[::-1]
# 测试代码
print(is_palindrome("racecar")) # 应输出 True
4. 数据结构
题目描述： 实现一个栈，支持基本的栈操作。
class Stack:
def __init__(self):
self.items = []
def push(self, item):
self.items.append(item)
def pop(self):
if not self.is_empty():
return self.items.pop()
return None
def peek(self):
if not self.is_empty():
return self.items[-1]
return None
def is_empty(self):
return len(self.items) == 0
# 测试代码
stack = Stack()
stack.push(1)
stack.push(2)
print(stack.pop()) # 应输出 2
5. 链表操作
题目描述： 实现一个单链表，支持插入和删除操作。
class ListNode:
def __init__(self, value=0, next=None):
self.value = value
self.next = next
class LinkedList:
def __init__(self):
self.head = None
def insert(self, value):
new_node = ListNode(value)
if not self.head:
self.head = new_node
else:
current = self.head
while current.next:
current = current.next
current.next = new_node
def delete(self, value):
current = self.head
previous = None
while current and current.value != value:
previous = current
current = current.next
if previous is None:
self.head = current.next
elif current:
previous.next = current.next
# 测试代码
ll = LinkedList()
ll.insert(1)
ll.insert(2)
ll.insert(3)
ll.delete(2)
print(ll.head.value) # 应输出 1
6. 递归
题目描述： 使用递归计算斐波那契数列的第n项。
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
# 测试代码
print(fibonacci(5)) # 应输出 5
7. 树
题目描述： 实现一个二叉搜索树，并实现插入和查找功能。
class TreeNode:
def __init__(self, value=0, left=None, right=None):
self.value = value
self.left = left
self.right = right
class BinarySearchTree:
def __init__(self):
self.root = None
def insert(self, value):
if not self.root:
self.root = TreeNode(value)
else:
self._insert(self.root, value)
def _insert(self, node, value):
if value < node.value:
if not node.left:
node.left = TreeNode(value)
else:
self._insert(node.left, value)
else:
if not node.right:
node.right = TreeNode(value)
else:
self._insert(node.right, value)
def search(self, value):
return self._search(self.root, value)
def _search(self, node, value):
if not node:
return False
if value == node.value:
return True
elif value < node.value:
return self._search(node.left, value)
else:
return self._search(node.right, value)
# 测试代码
bst = BinarySearchTree()
bst.insert(8)
bst.insert(3)
bst.insert(10)
print(bst.search(3)) # 应输出 True
8. 图
题目描述： 实现一个图数据结构，支持添加边和遍历。
class Graph:
def __init__(self):
self.adj_list = {}
def add_edge(self, u, v):
if u not in self.adj_list:
self.adj_list[u] = []
self.adj_list[u].append(v)
def traverse(self, start, visited=None):
if visited is None:
visited = set()
visited.add(start)
print(start, end=' ')
for neighbor in self.adj_list.get(start, []):
if neighbor not in visited:
self.traverse(neighbor, visited)
# 测试代码
graph = Graph()
graph.add_edge(1, 2)
graph.add_edge(2, 3)
graph.add_edge(3, 4)
graph.traverse(1) # 应输出 1 2 3 4
9. 算法设计
题目描述： 实现一个算法，找出数组中的最大子序列和。
def max_subarray_sum(arr):
max_current = max_global = arr[0]
for i in range(1, len(arr)):
max_current = max(arr[i], max_current + arr[i])
if max_current > max_global:
max_global = max_current
return max_global
# 测试代码
print(max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])) # 应输出 6
10. 动态规划
题目描述： 实现一个算法，找出最长的公共子序列。
def longest_common_subsequence(X, Y):
m, n = len(X), len(Y)
L = [[0] * (n + 1) for i in range(m + 1)]
for i in range(m + 1):
for j in range(n + 1):
if i == 0 or j == 0:
L[i][j] = 0
elif X[i - 1] == Y[j - 1]:
L[i][j] = L[i - 1][j - 1] + 1
else:
L[i][j] = max(L[i - 1][j], L[i][j - 1])
return L[m][n]
# 测试代码
print(longest_common_subsequence("AGGTAB", "GXTXAYB")) # 应输出 4
11. 字符串匹配
题目描述： 实现一个算法，使用KMP算法进行字符串匹配。
def compute_lps(pattern):
lps = [0] * len(pattern)
length = 0
i = 1
while i < len(pattern):
if pattern[i] == pattern[length]:
length += 1
lps[i] = length
i += 1
else:
if length != 0:
length = lps[length - 1]
else:
lps[i] = 0
i += 1
return lps
def kmp_search(text, pattern):
m, n = len(text), len(pattern)
lps = compute_lps(pattern)
i, j = 0, 0
while i < m:
if pattern[j] == text[i]:
i += 1
j += 1
if j == n:
return i - j
elif i < m and pattern[j] != text[i]:
if j != 0:
j = lps[j - 1]
else:
i += 1
return -1
# 测试代码
print(kmp_search("ABABDABACDABABCABAB", "ABABCABAB")) # 应输出 10
12. 排序算法（快速排序）
题目描述： 实现一个快速排序算法。
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
# 测试代码
print(quick_sort([3, 6, 8, 10, 1, 2, 1])) # 应输出 [1, 1, 2, 3, 6, 8, 10]
13. 排序算法（归并排序）
题目描述： 实现一个归并排序算法。
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i, j = 0, 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result
# 测试代码
print(merge_sort([38, 27, 43, 3, 9, 82, 10])) # 应输出 [3, 9, 10, 27, 38, 43, 82]
14. 字符串压缩
题目描述： 实现一个字符串压缩算法，如Huffman编码。
from collections import Counter
def huffman_encoding(data):
frequency = Counter(data)
priority_queue = [[weight, [symbol, ""]] for symbol, weight in frequency.items()]
priority_queue.sort(key=lambda x: x[0])
while len(priority_queue) > 1:
lo = priority_queue[0]
hi = priority_queue[1]
merged = [lo[0] + hi[0], lo[1][0] + hi[1][0]]
priority_queue.pop(0)
priority_queue.pop(0)
priority_queue.append(merged)
priority_queue.sort(key=lambda x: x[0])
return priority_queue[0][1]
# 测试代码
print(huffman_encoding("this is an example of a huffman tree")) # 应输出编码后的字符串
15. 字符串解析
题目描述： 实现一个算法，解析并打印出HTML标签。
import re
def parse_html(html):
tag_pattern = re.compile(r'<(\w+)[^>]*>')
tags = re.findall(tag_pattern, html)
for tag in tags:
print(tag)
# 测试代码
html_content = "<html><body><h1>Hello, World!</h1></body></html>"
parse_html(html_content) # 应输出 'html', 'body', 'h1'
16. 网络爬虫
题目描述： 实现一个简单的网络爬虫，爬取网页内容。
import requests
def simple_crawler(url):
response = requests.get(url)
return response.text
# 测试代码
print(simple_crawler("https://www.example.com")) # 应输出网页内容
17. 数据库操作
题目描述： 实现一个简单的数据库操作，如插入、查询和更新。
import sqlite3
def create_db():
conn = sqlite3.connect('example.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS users
(id INTEGER PRIMARY KEY, name TEXT, email TEXT)''')
conn.commit()
conn.close()
def insert_user(name, email):
conn = sqlite3.connect('example.db')
c = conn.cursor()
c.execute("INSERT INTO users (name, email) VALUES (?, ?)", (name, email))
conn.commit()
conn.close()
def query_user(email):
conn = sqlite3.connect('example.db')
c = conn.cursor()
c.execute("SELECT * FROM users WHERE email=?", (email,))
user = c.fetchone()
conn.close()
return user
def update_user(email, name):
conn = sqlite3.connect('example.db')
c = conn.cursor()
c.execute("UPDATE users SET name=? WHERE email=?", (name, email))
conn.commit()
conn.close()
# 测试代码
create_db()
insert_user("John Doe", "john@example.com")
print(query_user("john@example.com")) # 应输出 ('1', 'John Doe', 'john@example.com')
update_user("john@example.com", "John Smith")
print(query_user("john@example.com")) # 应输出 ('1', 'John Smith', 'john@example.com')
18. 文件操作
题目描述： 实现一个文件操作，读取文件内容并打印。
def read_file(filename):
with open(filename, 'r') as file:
content = file.read()
print(content)
# 测试代码
read_file("example.txt") # 应输出文件内容
19. 网络编程
题目描述： 实现一个简单的TCP服务器和客户端。
import socket
# 服务器代码
def server():
host = '127.0.0.1'
port = 65432
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.bind((host, port))
s.listen()
conn, addr = s.accept()
with conn:
print(f"Connected by {addr}")
while True:
data = conn.recv(1024)
if not data:
break
print(data.decode())
# 客户端代码
def client():
host = '127.0.0.1'
port = 65432
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((host, port))
s.sendall(b'Hello, server!')
# 运行服务器和客户端
if __name__ == "__main__":
from threading import Thread
server_thread = Thread(target=server)
client_thread = Thread(target=client)
server_thread.start()
client_thread.start()
server_thread.join()
client_thread.join()
20. 异常处理
题目描述： 实现一个异常处理机制，捕获并处理潜在的错误。
def divide(a, b):
try:
result = a / b
except ZeroDivisionError:
print("Cannot divide by zero")
else:
print("Result:", result)
# 测试代码
divide(10, 0) # 应输出 "Cannot divide by zero"
21. 面向对象编程
题目描述： 实现一个面向对象的编程示例。
class Car:
def __init__(self, brand, model, year):
self.brand = brand
self.model = model
self.year = year
def start_engine(self):
print(f"{self.brand} {self.model}'s engine started.")
# 测试代码
my_car = Car("Toyota", "Corolla", 2020)
my_car.start_engine() # 应输出 "Toyota Corolla's engine started."
22. 单元测试
题目描述： 实现一个单元测试，测试上述Car类的功能。
import unittest
class TestCar(unittest.TestCase):
def test_start_engine(self):
car = Car("Toyota", "Corolla", 2020)
with self.assertRaises(SystemExit):
car.start_engine()
# 运行测试
if __name__ == '__main__':
unittest.main()
23. 生成器
题目描述： 实现一个生成器，用于生成斐波那契数列。
def fibonacci_generator(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
# 测试代码
for number in fibonacci_generator(10):
print(number) # 应输出斐波那契数列的前10个数
24. 装饰器
题目描述： 实现一个装饰器，用于计算函数执行时间。
import time
def timer(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"{func.__name__} took {end_time - start_time} seconds to execute.")
return result
return wrapper
@timer
def sleep_for(seconds):
time.sleep(seconds)
# 测试代码
sleep_for(2) # 应输出执行时间
25. 异常处理（自定义异常）
题目描述： 实现一个自定义异常类，用于处理特定错误。
class DivisionByZeroError(Exception):
pass
def divide(a, b):
if b == 0:
raise DivisionByZeroError("Cannot divide by zero")
return a / b
# 测试代码
try:
divide(10, 0)
except DivisionByZeroError as e:
print(e) # 应输出 "Cannot divide by zero"
26. 多线程
题目描述： 实现一个多线程示例，打印数字序列。
”`python import threading
def print_numbers(start, end):