193 lines
9.8 KiB
HTML
193 lines
9.8 KiB
HTML
|
||
<!DOCTYPE html>
|
||
<html>
|
||
<head>
|
||
<meta charset="UTF-8">
|
||
<title>Document</title>
|
||
<!-- 你的其他样式 -->
|
||
|
||
<script src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
|
||
<script>
|
||
MathJax.config = {
|
||
tex: {
|
||
inlineMath: [['$', '$'], ['\(', '\)']]
|
||
},
|
||
svg: {
|
||
fontCache: 'global'
|
||
}
|
||
};
|
||
</script>
|
||
|
||
</head>
|
||
<body>
|
||
<h1>算法设计范式：分而治之与归并排序</h1>
|
||
<blockquote>
|
||
<p>Auto-generated at 2025-09-22 15:38</p>
|
||
</blockquote>
|
||
<h2>算法设计范式：分而治之与归并排序</h2>
|
||
<h3>分治法：分而治之</h3>
|
||
<h4>引入</h4>
|
||
<p>在算法分析与设计中，有一些设计算法解决问题的通用方法可供大家选取尝试，其中一个很常用的方法就叫做“分治法”，字如其意，
|
||
分治法就是将大问题分解为小问题（或说子问题），并将子问题持续分解下去，直到子问题可以用常数时间进行求解。
|
||
最基础的问题：何时可以用分治法？</p>
|
||
<ol>
|
||
<li>找最值问题</li>
|
||
<li>回文字符串</li>
|
||
</ol>
|
||
<h4>分治法的组成</h4>
|
||
<p>分治法有3个重要组成：分解、解决、合并。</p>
|
||
<p>有一些帮助我们进行这些操作的分析与设计原则：</p>
|
||
<ol>
|
||
<li><strong>子问题相似</strong>：分解出的子问题与原问题类型一致，可复用相同解法，保证递归或分治逻辑的一致性。</li>
|
||
<li><strong>子问题互不干扰</strong>：子问题边界清晰、数据独立，避免相互影响，简化问题拆解与求解逻辑。</li>
|
||
<li><strong>合并代价可控</strong>：子问题解合并为原问题解的时间 / 空间开销在可接受范围，避免抵消分治带来的效率提升。</li>
|
||
</ol>
|
||
<h4>分治法的时间复杂度迭代公式</h4>
|
||
<p>T（n）= 子问题数量 * T（ 子问题规模 ） + 合并这些子问题的解的用时</p>
|
||
<h3>归并算法理论分析</h3>
|
||
<p><strong>案例背景：智慧城市交通优化系统</strong></p>
|
||
<p>在上周的工作中，你已经实现并分析了插入排序在交通数据处理中的性能。虽然它在数据量较小或基本有序的情况下表现不错，但在应对大规模拥堵（逆序数据）时，其性能瓶颈非常明显。本周，你的项目经理（Agent）将向你介绍一种更高效的算法设计思想——“分而治之”，并要求你掌握其代表算法：归并排序。</p>
|
||
<h4>任务：理解与分析</h4>
|
||
<h5>场景介绍</h5>
|
||
<p>归并排序（Merge Sort）是解决大规模排序问题的利器。在投入编码之前，你必须先从理论上理解它为何如此高效。</p>
|
||
<h5>思考题</h5>
|
||
<p>请与右侧的Agent（你的项目经理）对话，清晰地回答以下问题，以证明你已理解核心思想：</p>
|
||
<ol>
|
||
<li>
|
||
<p><strong>分治思想</strong>：根据课程资料，请解释什么是“分而治之”（Divide-and-Conquer）设计范式？它包含哪三个基本步骤？</p>
|
||
</li>
|
||
<li>
|
||
<p><strong>递推关系</strong>：归并排序的时间复杂度可以用递推式 T(n)=2T(n/2)+Θ(n) 来表示。请解释这个式子各部分的含义：</p>
|
||
<ul>
|
||
<li><code>2</code> 代表什么？</li>
|
||
<li><code>T(n/2)</code> 代表什么？</li>
|
||
<li><code>Θ(n)</code> 代表什么？</li>
|
||
</ul>
|
||
</li>
|
||
<li>
|
||
<p><strong>效率对比</strong>：你的同事认为，插入排序经过极致优化后，处理n个数据的耗时为 <eq>0.1n^2</eq>；而归并排序由于递归和合并开销，耗时为 1000nlog_2n。在处理超大规模城市交通数据时（即n趋于无穷大时），哪个算法最终会胜出？请从渐进增长的角度解释你的理由。</p>
|
||
</li>
|
||
<li>
|
||
<p><strong>增长排序</strong>：将下列函数的渐进增长率从低到高排序，并将它们划分到等价类（即 Θ 关系相同的函数）。这有助于你理解不同算法效率的所在层级。</p>
|
||
<ul>
|
||
<li><eq>n^2</eq> (插入排序最坏情况)</li>
|
||
<li>nlogn (归并排序)</li>
|
||
<li>n (一种非常低效的蛮力算法)</li>
|
||
<li><eq>2^n</eq> (另一种指数级算法)</li>
|
||
<li>logn (类似二分查找的效率)</li>
|
||
</ul>
|
||
</li>
|
||
</ol>
|
||
<h3>归并排序的编程实现</h3>
|
||
<h4>任务：编码与对比</h4>
|
||
<h5>场景介绍</h5>
|
||
<p>现在你已经从理论上理解了归并排序的威力。是时候亲手实现它，并与上周的插入排序进行一次性能上的正面较量了！</p>
|
||
<h5>题目：实现归并排序并对比性能</h5>
|
||
<p>你需要实现归并排序的核心函数，并利用上周的测试框架来直观对比它与插入排序在处理不同交通数据时的表现。</p>
|
||
<h5>代码框架</h5>
|
||
<p>在下方代码编辑区，完成 <code>merge_sort(arr)</code> 和 <code>merge(left, right)</code> 两个函数的实现。</p>
|
||
<pre><code class="language-python">import random
|
||
import time
|
||
|
||
#上周实现的插入排序（用于对比）
|
||
def insertion_sort(arr):
|
||
for i in range(1, len(arr)):
|
||
key = arr[i]
|
||
j = i - 1
|
||
while j >= 0 and arr[j] > key:
|
||
arr[j + 1] = arr[j]
|
||
j -= 1
|
||
arr[j + 1] = key
|
||
return arr
|
||
|
||
#--- 本周任务：请在下方实现归并排序 ---
|
||
|
||
def merge_sort(arr):
|
||
"""
|
||
实现归并排序算法
|
||
参数arr: 待排序的交通数据数组
|
||
返回: 一个新的、排序好的数组
|
||
"""
|
||
# TODO: 实现归并排序的递归逻辑
|
||
# 提示：当数组元素个数小于等于1时，递归终止
|
||
|
||
|
||
def merge(left, right):
|
||
"""
|
||
合并两个已排序的子数组
|
||
参数left: 左侧已排序数组
|
||
参数right: 右侧已排序数组
|
||
返回: 合并后的一个有序数组
|
||
"""
|
||
|
||
|
||
#--- 测试与对比部分 ---
|
||
|
||
def measure_performance(sort_func, data):
|
||
start_time = time.perf_counter_ns()
|
||
sort_func(data.copy())
|
||
end_time = time.perf_counter_ns()
|
||
return (end_time - start_time) / 10**6
|
||
|
||
network_sizes = [1000, 5000, 10000, 50000]
|
||
print("算法性能对比测试:")
|
||
for size in network_sizes:
|
||
# 生成逆序数据，这是插入排序的最坏情况
|
||
worst_case_data = list(range(size, 0, -1))
|
||
|
||
time_insertion = measure_performance(insertion_sort, worst_case_data)
|
||
time_merge = measure_performance(merge_sort, worst_case_data)
|
||
|
||
print(f"--- 网络规模 n={size} (最坏情况) ---")
|
||
print(f" - 插入排序: {time_insertion:.2f} ms")
|
||
print(f" - 归并排序: {time_merge:.2f} ms")
|
||
</code></pre>
|
||
<h5>分析与讨论</h5>
|
||
<p>完成编程并得到输出后，请与右侧Agent讨论以下问题：</p>
|
||
<ol>
|
||
<li>
|
||
<p><strong>性能验证</strong>：观察“交通大堵塞”（最坏情况）的测试结果，归并排序的性能表现与插入排序有何天壤之别？这是否验证了你在第一关的理论分析？</p>
|
||
</li>
|
||
<li>
|
||
<p><strong>性能稳定性</strong>：如果我们将测试数据换成“畅通无阻”（最好情况）或“随机车流”（平均情况），你认为归并排序的运行时间会发生巨大变化吗？为什么？</p>
|
||
</li>
|
||
<li>
|
||
<p><strong>空间成本</strong>：在实现 <code>merge</code> 函数时，你可能创建了一个新的数组 <code>merged</code> 来存放结果。这在算法分析中被称为“空间复杂度”。与在原数组上进行交换的插入排序相比，归并排序的这个特点是优点还是缺点？</p>
|
||
</li>
|
||
<li>
|
||
<p><strong>最终决策</strong>：作为项目工程师，你会选择哪种排序算法用于我们的大规模交通调度系统？请综合考虑<strong>时间效率</strong>和<strong>空间成本</strong>来陈述你的理由。</p>
|
||
</li>
|
||
</ol>
|
||
<h3>进一步研究分治问题的时间复杂度分析</h3>
|
||
<p>分治问题的两种时间复杂度分析方法：主方法和递归树法。</p>
|
||
<h4>主方法</h4>
|
||
<p>主方法本质是一种速算公式，针对于分治迭代式是这样的形式的：T(n)=aT(n/b)+f(n)，a>=1，b>1。
|
||
主方法概念上理解，就是比较分治法的“子问题总数”和“合并总数”，在问题复杂度上，哪个为“主”，就按照这个主部分计算时间复杂度。
|
||
（因为时间复杂度公式上，我们只会保留增长最快的那一项，也就是“主项”）</p>
|
||
<p>严格定义这里就略了，直接看口诀：</p>
|
||
<ol>
|
||
<li>算log_b (a)，得到n^log_b (a)；</li>
|
||
<li>比f(n)和n^log_b (a)的增长速度：</li>
|
||
</ol>
|
||
<ul>
|
||
<li>前者慢 → O(n^log_b (a))；</li>
|
||
<li>差不多 → O(n^log_b (a) · log n)（k=0 时）；</li>
|
||
<li>前者快且满足正则条件 → O(f(n))。</li>
|
||
<li>其中正则条件是存在0<c<1，使得：a·f(n/b)≤ c·n²</li>
|
||
</ul>
|
||
<p>试着计算一下：T(n) = 3T(n/2) + O(n²) 这个迭代式的时间复杂度</p>
|
||
<h4>递归树法</h4>
|
||
<p>递归树相对更容易理解（可能之前的问题你已经在不知觉中使用递归树法），因为这种方法完全就是对分治方法本身的全流程模拟。</p>
|
||
<p>步骤 1：画树 —— 把问题拆解成 “节点”，标记每个节点的分解与合并耗时（父节点的解决耗时其实就是自己的所有子节点的分解与合并耗时）
|
||
a. 根节点：写原问题的规模 n 和分解 / 合并耗时 f (n)
|
||
b. 子节点：根节点拆成几个子问题，就画几个子节点，每个子节点写 “子问题规模 + 子问题的分解 / 合并耗时”
|
||
c. 叶子节点：当子问题规模小到能直接解决（比如 n=1），就停止拆解，叶子节点写 “规模 1，耗时 Θ(1)”
|
||
步骤 2：算层 —— 求每一层的总耗时
|
||
同一层的节点，代表 “同一轮拆解的所有问题”，它们的耗时总和就是这一层的总代价
|
||
步骤 3：求和 —— 总耗时 = 所有层的代价之和
|
||
先确定树有多少层，再把每层的总代价加起来</p>
|
||
<p>试着计算：无法用主方法解决的问题： T (n)=T (n/3)+T (2n/3)+2*n</p>
|
||
|
||
</body>
|
||
</html>
|
||
|