算法设计第4章分治法
cout<<"移动后的数组为："<<endl;
for(int i=0;i<n;i++)
{
cout<<A[i];
}
cout<<endl;
}
/*
题目描述：在有序序列（r1,r2,r3····rn）中，存在序号i（1<=i<=n）,
使得ri = i;请设计一个分治算法找到这个元素，要求算法在最坏的情况下的
{
for(int i=0;i<(to-from+1)/2;i++)
{
char temp=A[from+i];
A[from+i]=A[to-i];
A[to-i]=temp;
}
}
void Converse(char *A,int n,int k)
{
Reverse(A, 0, k-1);
Reverse(A, k, n-1);
#include <iostream>
using namespace std;
int Max(int a[], int low, int high);
int main()
{
int a[1000], m,n;
cout<<"请输入数组的个数：";
cin>>n;
for(int i = 0;i < n;i++)
*/
/*
算法：
1.实现相邻两端相同编号的数进行移动
2.k个函数调用实现每个序号的书都进行移动
3.输出数组
*/
#include <iostream>
using namespace std;
void Converse(char *A,int n,int k) ;
void Reverse(char *A, int from, int to);
int main()
{
char A[100];
int k;
cout<<"请输入数组："<<endl;
cin>>A;
cout<<"请输入左移的位数k："<<endl;
cin>>k;
Converse(A,strlen(A),k);
return 0;
}
void Reverse(char *A, int from, int to)
return max;
}
}
/*
题目描述：设计分治算法，实现将数组A[n]中所有的元素循环左移k个位置，要求时间
复杂度为，空间复杂度为，例如，对abcdefgh循环左移3位得到defghabc.
*/
/*
思路：将数组元素左移n块，则将数组分成几块，然后将每一块进行编号，
然后进行移动，序号相同的，前一段序号的那个数移到后一段序号的那个数即可。
{
cin>>a[i];
}
f(a,n);
return 0;
}
void f(int a[],int n)
{
int left = 0,right = n - 1,mid;
while(left < right)
{
mid = (left + right) / 2;
if(a[mid] = mid)
{
cout<<"这个元素是："<<a[mid]<<endl;
2.3.找到目标输出；
*/
#include<iostream>
using namespace std;
void f(int a[],int n);
int main ()
{
int a[1001];
int i,n;
cout<<"请输入有序数组的个数：";
cin>>n;
for(i = 0;i < n;i++)
a[i] = rand() %100;
for(int j = 0;j < n;j++)
cout<<a[j]<<" ";
cout<<endl;
m = Max(a, 0, n-1);
cout<<a[m]<<endl;
return 0;
}
int Max(int a[], int low, int high)
void QuickSort(int r[ ], int first, int end);
int main()
{
int r[10001];
int n,cont = 0,max = 0,temp;
cout<<"请输入数组的个数：";
cin>>n;
cout<<"请输入数组的元素：";
for(int j = 0;j < n;j++)
{
int mid, max, max1, max2;
if(low==high) return low;
else
{
mid=(low+high)/2;
max1=Max(a, low, mid);
max2=Max(a, mid+1, high);
max = a[max1]>a[max2]?max1: max2;
时间性能为O(log2n);
*/
/*
思路：这道题主要采用的是折半查找的思路，同时也体现出了分治法；
把一个大的问题折半折半再折半···的处理，最终就可以找到目标。
*/
/*
算法：
1.输入数组
2.定义折半查找的函数；
2.1.折半找到中间的数比较r[i]和i的大小；
2.2.如果r[i] > i则我们就直接在数组的左边找；否则就在右边找。
cin>>r[j];
QuickSort(r,0,n-1);
for(int i = 0;i < n;i++)
{
int k = i + 1;
while(r[i] == r[k] && i < n)
此时算法的时间复杂性为nlog(n);
*/
/*
算法：
1.输入数组；
2..输出众数。
*/
#include <iostream>
using namespace std;
int Partition(int r[ ], int first, int end);
/*
题目描述：设计分治算法求一个数组中的最大元素。
*/
/*
思路：要用分治法来解决数组中的最大了元素，我们可以采用递归的思想，
两两比较用小标的变化来标志出存储最大的元素。
*/
/*
算法：
1.首先输入数组的个数
2.用rand()随机产生数组
3.调用递归函数
3.1递归函数找到最大元素的下标
4.输出最大元素
*/
break;
}
else if(a[mid] > mid)
right = mid;
else
left = mid;
}
}
/*
题目描述：在一个序列中出现次数最多的元素称为众数，
请设计算法寻找众数并分析算法的时间复杂性；
*/
/*
思路：题目要求是要用分治法，那我们就只有在排序上用分治法，
将数组用快速排序，之后再遍历一次数组我们就可以找到众数。
分治法的简单描述
分治法的简单描述分治法是一种算法设计的思想，它将一个大问题分解为多个小问题，通过解决小问题来解决大问题。
这种思想的应用非常广泛，可以用来解决各种问题，比如排序、查找、计算等等。
下面我们来详细介绍一下分治法的基本原理和应用。
分治法的基本原理是将一个问题分解为多个独立的子问题，然后对每个子问题进行求解，最后将子问题的解合并起来得到原问题的解。
这种分解和合并的过程可以递归地进行，直到问题变得足够简单，可以直接求解为止。
在应用分治法解决问题时，需要满足以下三个条件：1.原问题可以分解为多个独立的子问题；2.子问题的结构与原问题相同，只是规模更小；3.子问题的解可以合并得到原问题的解。
接下来我们来看两个分治法的经典应用：归并排序和快速排序。
归并排序是一种经典的排序算法，它的基本思想就是使用分治法将一个无序的序列分解为多个有序的子序列，然后再将这些子序列合并起来得到一个有序的序列。
具体的步骤如下：1.将序列分成两个子序列，分别对这两个子序列进行归并排序；2.将两个有序的子序列合并成一个有序的序列。
归并排序的时间复杂度为O(nlogn)，其中n是序列的长度。
它的空间复杂度为O(n)，其中n是序列的长度。
快速排序是另一种经典的排序算法，它的基本思想也是使用分治法将一个无序的序列分解为多个有序的子序列，然后再将这些子序列合并起来得到一个有序的序列。
具体的步骤如下：1.从序列中选择一个元素作为基准值，将序列分成两个子序列，一个小于基准值，一个大于基准值；2.分别对这两个子序列进行快速排序；3.将两个有序的子序列合并成一个有序的序列。
快速排序的时间复杂度取决于基准值的选择，最坏情况下的时间复杂度为O(n^2)，其中n是序列的长度。
但是平均情况下的时间复杂度为O(nlogn)，空间复杂度为O(logn)。
除了排序问题，分治法还可以应用于其他一些问题，比如最大子数组和问题。
给定一个整数数组，找到一个具有最大和的连续子数组。
启发式规则_分治法汉诺塔4
汉诺塔问题可以通过以下三个步骤实现： （1）将塔A上的n-1个碟子借助塔C先移到塔B上。 （2）把塔A上剩下的一个碟子移到塔C上。 （3）将n-1个碟子从塔B借助塔A移到塔C上。 显然，这是一个递归求解的过程
Hanoi塔问题, 算法分析如下，设A上有n个盘子。 如果n=1，则将圆盘从A直接移动到C。 如果n=2，则： （1）将A上的n-1（等于1）个圆盘移到B上； （2）再将A上的一个圆盘移到C上； （3）最后将B上的n-1（等于1）个圆盘移到C上。 如果n=3，则： A）将A上的n-1（等于2，令其为n`）个圆盘移到B（借助于C），步 骤如下： （1）将A上的n`-1（等于1）个圆盘移到C上。 （2）将A上的一个圆盘移到B。 （3）将C上的n`-1（等于1）个圆盘移到B。 B）将A上的一个圆盘移到C。 C）将B上的n-1（等于2，令其为n`）个圆盘移到C（借助A），步骤 如下： （1）将B上的n`-1（等于1）个圆盘移到A。 （2）将B上的一个盘子移到C。 （3）将A上的n`-1（等于1）个圆盘移到C。到此，完成了三个圆盘的 移动过程。
5, 3, A, B, C ⑴
5, 2, A, C, B 5, 3, A, B, C
⑹ 7, 1, A, B, C 7, 2, B, A, C 5, 3, A, B, C ⑾
5, 3, A, B, C ⑺
7, 2, B, A, C 5, 3, A, B, C
⑻
7, 2, B, A, C 5, 3, A, B, C ⑽
4.2 递 归
4.2.1 递归的定义
4.2.2 递归函数的运行轨迹
4.2.3 递归函数的内部执行过程
4.2.1 递归的定义
递归（Recursion）就是子程序（或函数）直 接调用自己或通过一系列调用语句间接调用自己， 是一种描述问题和解决问题的基本方法。 递归有两个基本要素： ⑴ 边界条件：确定递归到何时终止； ⑵ 递归模式：大问题是如何分解为小问题的。
分治算法
65 97
13 76
38 49 65 97
13 27 76
13 27 38 49 65 76 97
黑盒划分典型问题—合并排序
合并排序算法改进
从分治过程入手，容易消除mergeSort算法中的递归 调用
49 38 65 97 76 13 27
38 49
65 97
13 76
27
38 49 65 97
题的解，自底向上逐步求出原来问题的解。
T(n)
=
n
递归的概念
由分治法产生的子问题往往是原问题的较小模式，这 就为使用递归技术提供了方便。在这种情况下，反复 应用分治手段，可以使子问题与原问题类型一致而其 规模却不断缩小，最终使子问题缩小到很容易直接求 出其解。这自然导致递归过程的产生。
直接或间接地调用自身的算法称为递归算法。用函数 自身给出定义的函数称为递归函数。
黑盒划分典型问题—合并排序
【例5】合并排序
任务描述：任意给定一包含n个整数的集合，把n个整数按升序排列。 输入：每测试用例包括两行，第一行输入整数个数，第二行输入n个整 数，数与数之间用空格隔开。最后一行包含-1，表示输入结束。 输出：每组测试数据的结果输出占一行，输出按升序排列的n个整数。 样例输入：
13 27 76
13 27 38 49 65 76 97
黑盒划分典型问题—合并排序
黑盒划分典型问题—合并排序
合并排序算法改进
从分治过程入手，容易消除mergeSort算法中的递归调用 自然合并排序
49 38 65 97 76 13 27
49
38 65 97
76
13 27
38 49 65 97
黑盒划分典型问题—逆序对问题
算法设计与分析：递归与分治法-实验报告(总8页)
算法设计与分析：递归与分治法-实验报告(总8页)实验目的：掌握递归与分治法的基本思想和应用，学会设计和实现递归算法和分治算法，能够分析和评价算法的时间复杂度和空间复杂度。
实验内容：1.递归算法的设计与实现3.算法的时间复杂度和空间复杂度分析实验步骤：1）递归定义：一个函数或过程，在其定义或实现中，直接或间接地调用自身的方法，被成为递归。
递归算法是一种控制结构，它包含了解决问题的基础情境，也包含了递归处理的情境。
2）递归特点：递归算法具有以下特点：①依赖于递归问题的部分解被划分为若干较小的部分。
②问题的规模可以通过递推式递减，最终递归终止。
③当问题的规模足够小时，可以直接求解。
3）递归实现步骤：①确定函数的定义②确定递归终止条件③确定递归调用的过程4）经典实例：斐波那契数列递推式：f(n) = f(n-1) + f(n-2)int fib(int n) {if (n <= 0)return 0;else}5）优化递归算法：避免重复计算例如，上述斐波那契数列的递归算法会重复计算一些中间结果，影响效率。
可以使用动态规划技术，将算法改为非递归形式。
int f1 = 0, f2 = 1;for (int i = 2; i <= n; i++) {f1 = f2;使用循环避免递归，重复计算可以大大减少，提高效率。
1）分治算法的定义：将原问题分解成若干个规模较小且类似的子问题，递归求解子问题，然后合并各子问题得到原问题的解。
2）分治算法流程：②将问题分解成若干个规模较小的子问题。
③递归地解决各子问题。
④将各子问题的解合并成原问题的解。
3）分治算法实例：归并排序归并排序是一种基于分治思想的经典排序算法。
排序流程：②分别对各子数组递归进行归并排序。
③将已经排序好的各子数组合并成最终的排序结果。
实现源代码：void mergeSort(int* arr, int left, int right) {if (left >= right)while (i <= mid && j <= right)temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];temp[k++] = arr[i++];1) 时间复杂度的概念：指完成算法所需的计算次数或操作次数。
分治法的概念
分治法的概念分治法的概念一、引言在计算机科学和数学领域中，分治法是一种重要的算法设计技术。
它将一个大问题划分成若干个小问题，然后递归地解决每个小问题，并将它们的结果组合起来得到原问题的解。
分治法通常用于解决那些具有重叠子问题和具有相对独立性的子问题的问题。
二、分治法的基本思想分治法是一种递归式算法，其基本思想可以概括为三个步骤：1. 分解：将原问题划分成若干个规模较小、相互独立且与原问题形式相同的子问题。
2. 解决：递归地求解每个子问题。
如果子问题足够小，则直接求解。
3. 合并：将所有子问题的解合并成原问题的解。
三、分治法应用举例1. 归并排序归并排序是一种经典的排序算法，它采用了分治策略。
该算法将待排序数组不断切割为两半，直到每个子数组只剩下一个元素为止。
然后，对这些单元素数组进行合并操作，直到最终得到完整有序数组。
2. 快速排序快速排序也是一种经典的排序算法，它同样采用了分治策略。
该算法选择一个基准元素，将数组中小于等于基准元素的元素放到左边，大于基准元素的元素放到右边。
然后递归地对左右子数组进行排序。
3. 棋盘覆盖问题棋盘覆盖问题是一道经典的计算机科学问题，它可以用分治法来解决。
该问题要求在一个大小为2^n x 2^n的棋盘上，用L型骨牌覆盖所有空格，其中每个L型骨牌占据三个格子且不能重叠。
该问题可以通过将棋盘划分为四个大小相等、形状相似的子棋盘，并递归地解决每个子棋盘来得到解决。
四、分治法的优缺点1. 优点：分治法通常具有高效性和可扩展性。
由于它将大问题划分成若干个小问题，并且每个小问题都可以独立地求解，因此可以很容易地将算法并行化以提高效率。
2. 缺点：分治法通常需要额外的空间来存储子问题和合并结果。
此外，在实践中，分治法的递归深度可能非常大，这可能会导致堆栈溢出等问题。
五、总结分治法是一种重要的算法设计技术，它将一个大问题划分成若干个小问题，并递归地解决每个小问题，最终将它们的结果组合起来得到原问题的解。
分治法的步骤
分治法的步骤分治法是一种常见的算法设计策略，它将问题分解成更小的子问题，然后递归地解决每个子问题，最后将这些子问题的解合并起来得到原问题的解。
下面将详细介绍分治法的步骤。
一、分治法的定义和基本思想分治法是一种算法设计策略，它将一个大问题分解成若干个相互独立且结构相同的小问题，递归地求解这些小问题，并将它们的结果组合起来得到原问题的解。
在实际应用中，分治法通常用于处理那些具有重复性质或者可以通过递归实现的计算任务。
二、分治法的步骤1. 分解：首先将原问题划分为若干个规模较小、结构相似且独立的子问题。
这个过程通常称为“分解”（divide）。
2. 解决：对每个子问题进行递归求解。
如果子问题足够小而可以直接求解，则直接求解。
这个过程通常称为“解决”（conquer）。
3. 合并：将所有子问题的结果合并成原问题的结果。
这个过程通常称为“合并”（combine）。
三、应用场景1. 排序算法：例如归并排序、快速排序等。
2. 查找算法：例如二分查找。
3. 图论算法：例如最大子数组、矩阵乘法、汉诺塔等。
四、分治法的优缺点1. 优点：分治法可以有效地解决一些具有重复性质或者可以通过递归实现的计算任务，具有较高的效率和可扩展性。
2. 缺点：分治法需要额外的空间来存储子问题的结果，而且在递归过程中可能会出现栈溢出等问题，需要进行合理的优化。
同时，如果分解得不够合理或者子问题之间存在依赖关系，则可能会导致算法效率下降。
五、总结分治法是一种常见的算法设计策略，它将一个大问题划分为若干个规模较小、结构相似且独立的子问题，并递归地求解这些子问题。
在实际应用中，分治法通常用于处理那些具有重复性质或者可以通过递归实现的计算任务。
虽然分治法具有较高的效率和可扩展性，但也存在额外空间开销和栈溢出等问题，需要进行合理优化。
分治算法实验(用分治法查找数组元素的最大值和最小值)
算法分析与设计实验报告第一次实验附录：完整代码（分治法）#include<iostream>#include<time.h>#include<iomanip>using namespace std;//当数组中的元素个数小于3时，处理最大值int compmax(int A[],int start,int end){int max;if(start<end) //有两个元素{if(A[start]<=A[end])max=A[end];elsemax=A[start];}else//有一个元素max=A[start];return max;}//当数组中元素的个数小于2时，处理最小值int compmin(int A[],int start,int end){int min;if(start<end) //有两个元素{if(A[start]<=A[end])min=A[start];elsemin=A[end];}else//有一个元素min=A[start];return min;}//分治法处理整个数组，求最大值与最小值void merge(int a[],int left,int right,int &Max,int &Min) //Max,Min用来保存最大值与最小值//之所以使用&引用，是由于如果只是简单的使用变量，并不会改变Max与Min的值，使用指针也可以{int max1=0,min1=0,max2=0,min2=0;if(right-left>2) //当数组中元素个数大于等于3时，进行分治{int mid=(right+left)/2;merge(a,left,mid,max1,min1); //左半边递归调用自身，求出最大值最小值，分别保存在max1,min1中merge(a,mid+1,right,max2,min2); //右半边递归调用自身，求出最大值最小值，分别保存在max2,min2中if(max1>=max2) //子序列两两合并，求出最大值与最小值，保存在Max与Min中Max=max1;elseMax=max2;if(min1<=min2)Min=min1;elseMin=min2;}else//数组中元素个数小于3时的情况，直接赋值{Max=compmax(a,left,right);Min=compmin(a,left,right);}}void ran(int *input,int n) //随机生成数组元素函数{int i;srand(time(0));for(i=0;i<n;i++)input[i]=rand();input[i]='\0';}int a[1000000]; //定义全局变量用来存放要查找的数组int main(){int n;int i;int max;int min;cout<<"请输入要查找的序列个数："<<endl;for(i=0;i<5;i++){cin>>n;ran(a,n);clock_t start,end,over; //计算程序运行时间的算法start=clock();end=clock();over=end-start;start=clock();merge(a,0,n-1,max,min); //调用分治法算法cout<<max<<" "<<min<<endl;end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK); //显示运行时间}system("pause"); //停止运行窗口return 0;}完整代码（非递归方法）#include<iostream>#include<time.h>#include<iomanip>using namespace std;void ran(int *input,int n) //随机生成数组元素函数{int i;srand(time(0));for(i=0;i<n;i++)input[i]=rand();input[i]='\0';}int a[1000000];int main(){int max=a[0],min=a[0];int i,j,n;cout<<"请输入数据规模："<<endl;for(j=0;j<5;j++){cin>>n;ran(a,n);clock_t start,end,over; //计算程序运行时间的算法start=clock();end=clock();over=end-start;start=clock();for(i=1;i<n;i++){if(a[i]>max)max=a[i];if(a[i]<min)min=a[i];}cout<<max<<" "<<min<<endl;end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK); //显示运行时间}system("pause");return 0;}。
分治法实验报告
算法实验报告一分治法实验一、实验目的及要求利用分治方法设计大整数乘法的递归算法，掌握分治法的基本思想和算法设计的基本步骤。
要求：设计十进制的大整数乘法，必须利用分治的思想编写算法，利用c语言（或者c++语言）实现算法，给出程序的正确运行结果。
（必须完成）设计二进制的大整数乘法，要求利用分治的思想编写递归算法，并可以实现多位数的乘法（利用数组实现），给出程序的正确运行结果。
（任选）二、算法描述1、输入两个相同位数的大整数u，v 输出uv的值判断大整数的位数i；w=u/10^(i/2);y=v/10^(i/2);x=u-w*10^(i/2);z= v-y*10^(i/2);然后将w,x,y,z代入公式求得最后结果uv=wy10^i+((w+x)(y+z)-wy-xz)10^(i/2)+xz三、调试过程及运行结果在实验中我遇到的问题：原来以为这两个大整数的位数不同，结果题目要求是相同位数的大整数在写10的多少次方时，写的是10^(i/2),10^(i)，结果不对，我就将它改成了for循环语句四、实验总结在本次实验中，我知道了分治算法，以及分治算法的基本思想。
我还掌握了编写大整数乘法的算法与步骤，以及如何修改在编写程序时遇到的问题。
五、附录（源程序代码清单）1、#include<iostream.h> int weishu(int x){int i;while(x!=0){ x=x/10;i++;}return i;}void main(){int u,v;cout<<输入两个位数相同的大整数:<<endl; cin>>u;cin>>v;int i,j,m,n;int p,x,y,z,w;int a=1;int b=1;i=weishu(u);for(int k=1;k<=i;k++){a=a*10;}for(int q=1;q<=i/2;q++) {b=b*10;}w=u/b;y=v/b;x=u-w*b;z=v-y*b;p=w*y*a+((w+x)*(y+z)-w*y-x*z)*b+x*z; cout<<u<<*<<v<<=<<p; }教师评语：成绩：√优良中及格不及格算法实验报告二动态规划法实验一、实验目的及要求利用动态规划方法设计背包问题算法，掌握动态规划法的基本思想和算法设计的基本步骤。
分治法实验报告
分治法实验报告分治法实验报告一、引言分治法是一种重要的算法设计策略，它将一个大问题分解成若干个小问题，并通过递归的方式解决这些小问题，最终将它们的解合并起来得到原问题的解。
本实验旨在通过实际案例，探索分治法的应用和效果。
二、背景在计算机科学领域，分治法常常被用于解决一些复杂的问题，如排序、搜索、图算法等。
它的核心思想是将问题划分为更小的子问题，然后分别解决这些子问题，最后将它们的解合并起来得到原问题的解。
通过这种方式，我们可以降低问题的复杂度，提高算法的效率。
三、实验目的本实验旨在通过实际案例，验证分治法在问题解决中的有效性，并探索其在不同问题上的应用效果。
通过对比不同算法的运行时间和结果准确性，评估分治法在不同场景下的适用性。
四、实验过程本次实验选取了两个典型的问题，分别是最大子数组和快速排序。
首先，我们使用分治法来解决最大子数组问题。
该问题要求在一个给定的数组中，找到一个连续子数组，使得该子数组的和最大。
我们将数组分为两半，分别求解左半部分和右半部分的最大子数组，然后再考虑跨越中点的最大子数组。
通过递归的方式，最终得到整个数组的最大子数组。
接着，我们使用分治法来实现快速排序算法。
快速排序是一种高效的排序算法，它的核心思想是通过选择一个基准元素，将数组分为两个部分，使得左边的元素都小于等于基准元素，右边的元素都大于等于基准元素。
然后，对左右两个部分分别递归地进行快速排序，最终得到有序的数组。
五、实验结果通过对最大子数组和快速排序问题的实验，我们得到了以下结果。
首先，分治法在解决最大子数组问题上表现出色。
通过将问题划分为更小的子问题，我们可以在较短的时间内找到最大子数组，大大提高了算法的效率。
其次，在快速排序问题上，分治法同样展现了强大的能力。
通过不断地划分数组并进行排序，我们可以快速得到有序的结果。
六、实验分析分治法作为一种重要的算法设计策略，具有许多优点。
首先，它可以将复杂的问题分解为简单的子问题，降低了问题的复杂度，提高了算法的效率。
分治法
{ tmpa[k]=a[i]; i++; k++; }
while (j<=high)
//将第2子表余下部分复制到tmpa
{ tmpa[k]=a[j]; j++; k++; }
for (k=0，i=low;i<=high;k++，i++) //将tmpa复制回a中
a[i]=tmpa[k];
free(tmpa);
QuickSort(a，s，i-1); //对左子序列递归排序
QuickSort(a，i+1，t); //对右子序列递归排序
}
}
【算法分析】快速排序的时间主要耗费在划分操作上，对长度为n的
区间进行划分，共需n-1次关键字的比较，时间复杂度为O(n)。
对n个记录进行快速排序的过程构成一棵递归树，在这样的递归树中， 每一层至多对n个记录进行划分，所花时间为O(n)。
divide-and-conquer(P)
{ if |P|≤n0 return adhoc(P);
将P分解为较小的子问题 P1，P2，…，Pk;
for(i=1;i<=k;i++)
//循环处理k次
yi=divide-and-conquer(Pi); return merge(y1，y2，…，yk); }
2，5，1，7，10， 6，9，4，3，8 顶
2，5，1，7，10
6，9，4，3，8
分解
2，5，1 7，10 6，9，4 3，8
2，5 1 7 10 6，9 4 3 8
合并
25
7，10 6 9
底 3，8
2，5