有很多算法在结构上是递归的：为了解决一个给定问题，算法要一次或多次地调用其自身来解决相关的子问题。这些算法通常采用分治策略：将原问题分成n个规模较小而结构与原问题相似的子问题。递归地解这些子问题，然后合并其结果就得到原问题的解。n=2时的分支法又称二分法。
用分治法求解一个问题，所需的时间是由子问题的个数，大小以及把这个问题分解为子问题所需的工作总量来确定的。一般来说，二分法（即把任意大小的问题尽可能地等分为两个子问题）较为有效。
分治法在每一层递归上都有三个步骤：
分解：将原问题分解成一系列子问题；
解决：递归地解各子问题。若子问题足够小，则直接解；
合并：将子问题的结果合并成原问题的解；
【例 1】合并排序
对序列A[1], A[2], ······, A[n] 进行合并排序。
算法分析：
合并排序的算法就是二分法。
分解：将n个元素各含 n / 2 个元素的子序列；
解决：用合并排序法对两个子序列递归地排序；
合并：合并两个已排序的子序列以得到排序结果。
在对子序列排序时，当其长度为1时递归结束。单个元素被视为是已排好序的。合并排序的关键步骤在于合并步骤中产生的两个已排好序的子序列
A[P...Q] 和 A[Q+1...R]
将它们合并成一个已排好序的子序列[P..R]。我们引入一个辅助过程merge(A, P, Q, R)来完成这一合并工作，其中A是数组，P, Q, R是下标。
现在就可以把merge过程作为合并排序的一个子过程来用了。下面是merge_sort(A, P, R)对数组A[P..R]进行排序。若P >= R，该子数组至多只有一个元素，当然就是已排序的。否则，分解步骤就计算出一个中间下标Q，而将A[P..R]分成A[P..Q]和A[Q+1..R]。若数组A[P..R]的元素个数K = R - P + 1为偶数，则两个数组各含K/2个元素；否则A[P..Q]含[k/2] + 1个元素、A[Q + 1, R] 含[k/2]个元素。
我们只要调用merge_sort(A, 1, N)便可对整个序列A[1] ······ A[n]进行合并排序。如果我们自底向上（此处“底”为n是2的幂时）来看这个过程的操作时，算法将两个长度为1的序列合并成排好序的长度为2的序列，继而合并成长度为4的序列 ······ ，依次类推。随着算法自底向上执行，被合并的排序序列长度逐渐增加，一直进行到将两个长度为n/2的序列合并成最终排好序的长度为n的序列。下图列出了对序列（5，2，4，6，1，3，2，6）进行合并排序的过程。
算法的代码实现为：
public class MergeImpl {
public static void main(String[] args) {
int[] a = {5, 2, 4, 6, 1, 3, 2, 6};
new MergeImpl().merge_sort(a, 0 , a.length - 1);
for (int i=0; i < a.length; i++){
System.out.print(a[i] + " ");
}
}
private void merge(int[] list, int start, int mid, int end){
int t = start;
int i = start;
int j = mid + 1;
int[] lt = new int[list.length];
while (t <= end) {
if (i <= mid && (j > end || list[i] <= list[j])) {
lt[t] = list[i];
i++;
}
else {
lt[t] = list[j];
j++;
}
t++;
}
for (i = start; i <= end; i++){
list[i] = lt[i];
}
}
private void merge_sort(int[] list, int start, int end){
int mid;
if (start != end) {
mid = (start + end - 1) / 2;
merge_sort(list, start, mid);
merge_sort(list, mid + 1, end);
merge(list, start, mid, end);
}
}
}
执行结果为：
1 2 2 3 4 5 6 6
