归并排序(非递归算法)
#include
using namespace std;
void Process(int n);
void MergeSort(int ori[],int n);
void newMerge(int ori[],int tmpArray[],int s,int n);//没有完成整个归并时，用这个函数归并两个相邻的已排序的数组
void Merge(int ori[],int tmpArray[],int left,int mid,int right); //归并两个已排好序的数组到tmpArray中
void Output(int op[],int n); //用来输出数组
int main()
{
int n;
cin >> n;
Process(n);
return 0;
}
void Process(int n)
{
int ori[n+1];
for(int i = 1; i <= n; ++i)
cin >> ori[i];
if( n > 1) //如果不止一个待排元素，就归并
MergeSort(ori,n); //原始调用MergeSort
else
Output(ori,n);
}
void MergeSort(int ori[],int n)
{
int s = 1,tmpArray[n+1]; //s是每趟归并两个数组时，一个数组的长度(最后那个数组长度可能小于s)
while(s < n)
{
newMerge(ori,tmpArray,s,n);
s *= 2;
}
}
void newMerge(int ori[],int tmpArray[],int s,int n)
{
//没有完成整个归并时，用这个函数归并两个相邻的已排序的数组
int i = 1;
while(i <= n - 2 * s + 1) //利用i + 2s - 1 <= n可以得出
{
Merge(ori,tmpArray,i,i + s - 1,i + 2*s - 1);
i += 2 * s;
}
if(i <= n - s) //即最后的两个中，后面那个的长度不够s了
Merge(ori,tmpArray,i,i + s - 1,n);
else //即归并到最后，只剩一个长度不够s的了，只需直接复制到tmpArray[]中for(; i <= n; ++i)
tmpArray[i] = ori[i];
//至此，完成一趟归并
//再copy回ori[]中,to code here
for(int k = 0; k <= n; ++k)
ori[k] = tmpArray[k];
Output(ori,n);
}
void Merge(int ori[],int tmpArray[],int left,int mid,int right)
{
//归并两个已排好序的数组到tmpArray[]中,然后再copy回ori[]中
int tmpCnt = left; //临时计数器
int rightStart = mid + 1; // mid其实是leftEnd
while(left <= mid && rightStart <= right)
{
if(ori[left] <= ori[rightStart])
tmpArray[tmpCnt++] = ori[left++];
else
tmpArray[tmpCnt++] = ori[rightStart++];
}
//下面为谁有多就把谁直接放到tmpArray[]中
while(left <= mid)
tmpArray[tmpCnt++] = ori[left++];
while(rightStart <= right)
tmpArray[tmpCnt++] = ori[rightStart++];
}
void Output(int op[],int n)
{
for(int i = 1; i <= n; ++i)
cout << op[i] << " ";
cout << endl;
}
算法设计实验一归并排序(分治)和插入排序的比较分析
沈阳化工大学实验报告 课程名称算法设计与分析 项目名称归并排序(分治)和插入排序的比较 学院应用技术学院 专业计中职1401 指导教师张雪 报告人张庭浩学号 1422030125 实验时间 2016.11.05 提交时间 2016.11.05
一、实验目的 1.理解和掌握分治算法的相关内容。 2.具体完成插入排序和归并排序性能的比较。 二、实验内容 编写一个真随机函数，随机产生大量数字。在产生相同的一组大量随机数字后，分别用归并排序和插入排序两种算法进行排序，并通过时间函数分别计算出运行的时间。 三、伪代码 1.归并排序 /*数组a[]是原始数组，数组b[]是目标数组*/ 归并排序（数组a[],数组b[]）{ `分割与归并（数组a[],0, a.length,数组b[]) } /*通过递归把要排序的子序列分的足够小*/ 分割与归并（数组a[],起始位置,结束位置,数组b[]){ if(结束位置- 起始位置< 2) 返回 中间位置= （起始位置+结束位置）/2 分割与归并（数组a[],起始位置,中间位置,数组b[]) 分割与归并（数组a[],中间位置,结束位置,数组b[]) 归并（数组a[],起始位置，中间位置，结束位置，数组b[]) 拷贝（数组a[],起始位置，结束位置，数组b[]) } 归并（数组a[],起始位置，中间位置，结束位置，数组b[]){ i0 = 起始位置，i1 = 中间位置 for j = 起始位置到结束位置 if(i0 < 中间位置且（i1 > 结束位置或a[i0] <= a[i1]){ //当i0没有超过中间位置时，有两种情况要将a[i0]复制到b[j]上： //1.i1已经超过结束位置，只要把剩下的复制过来就好； //2.a[i0]比a[i1]小 b[j]=a[i0] i0++ } else { b[j]=a[i1] i1++ } }
简单的归并排序算法例子
import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Random; public class GuiBing { public static void main(String[] args) throws Exception { int datalength=1000000; GuiBing gui=new GuiBing(); int[] array1=gui.createArray(datalength); int[] array2=gui.createArray(datalength); Thread.sleep(20000); long startTime = System.nanoTime();//纳秒精度 long begin_freeMemory=Runtime.getRuntime().freeMemory(); int[] final_array=gui.guibing(array1,array2); boolean result=gui.testResult(final_array); long end_freeMemory=Runtime.getRuntime().freeMemory(); System.out.println("result===="+result); long estimatedTime = System.nanoTime() - startTime; System.out.println("elapsed time(纳秒精 度):"+estimatedTime/100000000.0); System.out.println("allocated memory:"+(begin_freeMemory-end_freeMemory)/1000.0+" KB"); Thread.sleep(20000); } /** * 显示数组的内容 * @param array */ private static void dispalyData(int[] array) { for(int i=0;i 实验一归并排序 一、实验目的 （1）掌握归并排序算法的思想； （2）掌握归并排序算法的程序实现。 二、实验环境 Windows 2000以上版本的操作系统，运用java或C语言实现该算法。 三、实验内容 在main函数中定义数A[]={52,49,80,36,14,58,61,23,97}，调用归并排序函数MergeSort对A[]中的数据进行排序，调试并观察排序过程。 C语言实现： 1.#include 归并排序算法实现（迭代和递归）\递归实现归并排序的原理如下： 递归分割: 递归到达底部后排序返回: 最终实现排序： #include } while(i 篇一：归并排序与快速排序实验报告 一、实验内容： 对二路归并排序和快速排序对于逆序的顺序数的排序时间复杂度比较。 二、所用算法的基本思想及复杂度分析： 1、归并排序 1）基本思想：运用分治法，其分治策略为： ①划分：将待排序列 r1,r2,……,rn划分为两个长度相等的子序列 r1,……,rn/2和rn/2+1,……,rn。 ②求解子问题：分别对这两个子序列进行排序，得到两个有序子序列。 ③合并：将这两个有序子序列合并成一个有序子序列。 2）复杂度分析： 二路归并排序的时间代价是o(nlog2n)。二路归并排序在合并过程中需要与原始记录序列同样数量的存储空间，因此其空间复杂性o(n)。 2、快速排序： 1）基本思想：运用分治法，其分治策略为： ①划分：选定一个记录作为轴值，以轴值为基准将整个序列划分为两个子序列 r1……ri-1和ri+1……rn，轴值的位置i在划分的过程中确定，并且前一个子序列中记录的值均小于或等于轴值，后一个子序列中记录的值均大于或等于轴值。 ②求解子问题：分别对划分后的每一个子序列递归处理。 ③合并：由于对子序列r1……ri-1和ri+1……rn的排序是就地进行的，所以合并不需要执行任何操作。 2）复杂度分析： 快速排序在平均时间复杂性是o(nlog2n)。最坏的情况下是o(n^2)。 三、源程序及注释： 1、归并排序 #include<iostream> #include<fstream> #include windows.h using namespace std; void merge(int r[],int r1[],int s,int m,int t ) } int mergesort(int r[],int r1[],int s,int t) { } void main() int i=s; int j=m+1; int k=s; while(i<=m&&j<=t) {} if(i<=m)while(i<=m) r1[k++]=r[i++];//第一个没处理完，进行收尾if(r[i]<=r[j])r1[k++]=r[i++];//取r[i]和r[j]中较小的放入r1[k]中else r1[k++]=r[j++]; else while(j<=t) r1[k++]=r[j++];//第二个没处理完，进行收尾for(int l=0;l<k;l++) { } r[l]=r1[l];//将合并完成后的r1[]序列送回r[]中if(s==t)r1[s]=r[s]; else{int m; m=(s+t)/2; mergesort(r,r1,s,m);//归并排序前半个子序列 mergesort(r,r1,m+1,t); //归并排序后半个子序列 merge(r1,r,s,m,t);//合并两个已排序的子序列 }return 0; int a[100000]; int a1[10000]; 归并排序算法的基本思想及算法实现示例 归并排序(Merge Sort)是利用"归并"技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。 两路归并算法 1、算法基本思路 设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。 （1）合并过程 合并过程中，设置i，j和p三个指针，其初值分别指向这三个记录区的起始位置。合并时依次比较R[i]和R[j]的关键字，取关键字较小的记录复制到R1[p]中，然后将被复制记录的指针i或j加1，以及指向复制位置的指针p加1。 重复这一过程直至两个输入的子文件有一个已全部复制完毕(不妨称其为空)，此时将另一非空的子文件中剩余记录依次复制到R1中即可。 （2）动态申请R1 实现时，R1是动态申请的，因为申请的空间可能很大，故须加入申请空间是否成功的处理。 2、归并算法 void Merge(SeqList R，int low，int m，int high) {//将两个有序的子文件R[low..m)和R[m+1..high]归并成一个有序的 //子文件R[low..high] int i=low，j=m+1，p=0；//置初始值 RecType *R1；//R1是局部向量，若p定义为此类型指针速度更快 R1=(ReeType *)malloc((high-low+1)*sizeof(RecType))； if(! R1) //申请空间失败 Error("Insufficient memory available!")； while(i<=m&&j<=high) //两子文件非空时取其小者输出到R1[p]上 R1[p++]=(R[i].key<=R[j].key)?R[i++]：R[j++]； while(i<=m) //若第1个子文件非空，则复制剩余记录到R1中 R1[p++]=R[i++]； while(j<=high) //若第2个子文件非空，则复制剩余记录到R1中 R1[p++]=R[j++]； for(p=0，i=low；i<=high；p++，i++) R=R1[p]；//归并完成后将结果复制回R[low..high] } //Merge 归并排序 归并排序有两种实现方法：自底向上和自顶向下。 实验名称归并排序分治策略的设计与实现实验方案实验成绩实验日期实验室信息系统设计与仿真室I 实验操作 实验台号班级姓名实验结果 一、实验目的 1、熟悉分治法求解问题的抽象控制策略； 2、熟悉在顺序存储表示下求解分类问题的递归算法设计； 3、通过实例转换, 掌握分治法应用。 二、实验任务 ①从文件中读取数据信息； ②利用归并排序算法，进行排序； ③输出排序结果。 三、实验设计方案 1、结构体设计 用数组存放排序数据。 2、自定义函数设计 ①函数原型声明 int input(int A[]); //从文件读入待排序的数据 void merge(int A[],int low,int mid,int high); // 两个相邻有序数组的归并 void mergesort(int A[],int low,int high); // 归并排序 void input(int A[], int n); // 输出排序结果 ②两个相邻的有序子数组的合并 思路：从两个已排好序的子数组的首元素开始，依次比较大小，按从小到大的顺序存放在b[]数组中，然后转存到A[]数组中。 void merge(int A[],int low,int mid,int high) { int b[N]; int i,j,k = 0; int l = low; //已排序部分1的起始下标 int h = mid+1; //已排序部分2的起始下标 while(l <= mid && h <= high) //两个有序部分合并到b数组中 if(A[l] < A[h]) b[k++] = A[l++]; else 归并排序是多次将相邻两个或两个以上的有序表合并成一个新的有序表。 最简单的归并是将相邻两个有序的子表合并成一个有序的表，即二路归并排序。1 、归并的思路 一次二路归并：将两个位置相邻的记录有序子序列归并为一个记录的有序序列。有序 序列R [low..high] 有序子序列R [low..mid]有序子序列R [mid+1..high] R [low..high] void Merge (RecType R[],int low,int mid,int high) {RecType *R1; int i=low,j=mid+1,k=0; //k 是R1的下标,i 、j 分别为第1、2段的下标 R1=(RecType *)malloc((high-low+1)*sizeof(RecType));while (i<=mid &&j<=high) if (R[i].key<=R[j].key)//将第1段中的记录放入R1中 {R1[k]=R[i];i++;k++;} else //将第2段中的记录放入R1中 {R1[k]=R[j];j++;k++;} Merge()：一次二路归并，将两个相邻的有序子序列归并为一个有 序序列。 空间复杂度为O(high-low+1) 2、二路归并算法 while(i<=mid)//将第1段余下部分复制到R1 {R1[k]=R[i];i++;k++;} while(j<=high)//将第2段余下部分复制到R1 {R1[k]=R[j];j++;k++;} for(k=0,i=low;i<=high;k++,i++)//将R1复制回R中R[i]=R1[k]; free(R1); } 算法分析与设计实验报告第二次实验 对于归并排序，在之前的数据结构已经学过了，本来以为代码实现起来会比较 附录： 完整代码（分治法） #include { for(int last=i;last<=mid;last++) { B[k++]=A[last]; } } } void mergesort(int a[],int b[],int left,int right) //分治法实现归并排序，利用递归实现{ if(left 1 排序 排序是数据处理中经常使用的一种重要运算，如何进行排序，特别是如何进行高效的排序，是计算机应用中的重要课题。排序的对象一般是一组记录组成的文件，而记录则是由若干数据项组成，其中的一项可用来标志一个记录，称为关键字项，该数据项的值称为关键字。所谓排序，就是要整理文件中的记录，使得它按关键字递增（或递减）的次序排列起来。若给定的文件含有n个记录｛R1，R2，…，R n｝，它们的关键字分别为｛K1，K2，…，K n｝，要把这n个记录重新排列成为｛R i1，R i2，…，R in｝，使得｛K i1≥K i2≥…≥K in｝（或｛K i1≤K i2≤…≤K in｝）。 本章主要介绍了枚举排序、快速排序、PSRS排序算法以及它们的MPI编程实现。1.1 枚举排序 1.1.1 枚举排序及其串行算法 枚举排序（Enumeration Sort）是一种最简单的排序算法，通常也称为秩排序（Rank Sort）。该算法的具体思想是（假设按关键字递增排序），对每一个待排序的元素统计小于它的所有元素的个数，从而得到该元素最终处于序列中的位置。假定待排序的n个数存在a[1]…a[n]中。首先将a[1]与a[2]…a[n]比较，记录比其小的数的个数，令其为k，a[1]就被存入有序的数组b[1]…b[n]的b[k+1]位置上；然后将a[2]与a[1]，a[3]…a[n]比较，记录比其小的数的个数，依此类推。这样的比较操作共n(n-1)次，所以串行秩排序的时间复杂度为O（n2）。 算法13.1 枚举排序串行算法 输入：a[1]…a[n] 输出：b[1]…b[n] Begin for i=1 to n do (1) k=1 (2) for j=1 to n do if a[i]>a[j] then k=k+1 end if end for (3) b[k]= a[i] end for End 1.1.2 枚举排序的并行算法 对该算法的并行化是很简单的，假设对一个长为n的输入序列使用n个处理器进行排序，只需是每个处理器负责完成对其中一个元素的定位，然后将所有的定位信息集中到主进程中，由主进程负责完成所有元素的最终排位。该并行算法描述如下： 算法13.2 枚举排序并行算法 关于多路归并排序外部排序败者树技术积累2009-11-24 21:52:06 阅读453 评论0 字号：大中小 编程珠玑第一个case是有关一个技巧性解决外部排序问题的。问题很巧妙的解决了，但一开始提到的利用归并排序进行外部排序的算法仍值得仔细探究一下，毕竟本科时学的不是很深入。 先来看内部排序中最简单的2路归并排序算法。 算法核心操作是将一维数组中前后相邻的两个有序序列归并为一个有序序列，给定数组中序列界限i、m、n，用2个下标变量分别从i和j=m+1开始逐个往后处理，先比较，小的写到结果序列的当前遍历下标k中，相应下标自增继续比较直到某个序列的下标走到边界，再将另外一个序列的剩余元素拷贝到结果序列中。 算法可用递归或递推实现，从相邻的两两元素开始不断调用上面的核心操作组成较长有序序列直到完成整个序列。 算法进行一趟归并就得到一个局部有序的完整新序列，n个元素共需要log2n趟归并，每趟完成比较操作n次（1次得到序列的1个值），得到的新序列写到结果序列空间中，下一趟之前要先将结果序列复制一份到临时空间，下一趟归并在临时空间上进行。因此时间复杂度nlog2n，空间上除了原始序列空间n、结果序列空间n，还需要辅助临时空间n。 接下来看外部排序。外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。外部排序最常用的算法是多路归并排序，即将原文件分解成多个能够一次性装入内存的部分，分别把每一部分调入内存完成排序。然后，对已经排序的子文件进行多路归并排序。 多路归并排序算法在常见数据结构书中都有涉及。从2路到多路（k路），增大k可以减少外存信息读写时间，但k个归并段中选取最小的记录需要比较k-1次，为得到u个记录的一个有序段共需要(u-1)(k-1)次，若归并趟数为s次，那么对n个记录的文件进行外排时，内部归并过程中进行的总的比较次数为s(n-1)(k-1)，也即(向上取整)(logkm)(k-1)(n-1)=(向上取整)(log2m/log2k)(k-1)(n-1)，而(k-1)/log2k随k增而增因此内部归并时间随k增长而增长了，抵消了外存读写减少的时间，这样做不行，由此引出了“败者树”tree of loser的使用。在内部归并过程中利用败者树将k个归并段中选取最小记录比较的次数降为(向上取整)(log2k)次使总比较次数为(向上取整)(log2m)(n-1)，与k无关。 败者树是完全二叉树，因此数据结构可以采用一维数组。其元素个数为k个叶子结点、k-1个比较结点、1个冠军结点共2k个。ls[0]为冠军结点，ls[1]--ls[k-1]为比较结点，ls[k]--ls[2k-1]为叶子结点（同时用另外一个指针索引b[0]--b[k-1]指向）。另外bk为一个附加的辅助空间，不属于败者树，初始化时存着MINKEY的值。 多路归并排序算法的过程大致为：首先将k个归并段中的首元素关键字依次存入 前言 1.1排序的重要性 生活中，无时不刻不充满这排序，比如：班级同学的成绩排名问题，公司产值高低的问题等等，解决这些问题的过程中，都涉及到了一个数据结构的构造思想过程。数据结构中的排序，也有很多种，如：插入排序、交换排序、选择排序等等，此时我们就要注意选择具有优解的算法，将一个数据元素（或记录）的任意序列，重新排列成一个有序的排列，便于我们查找。 假设含有n个记录的序列为{R1,R2,Rn},其相应的关键字序列为{K1,K2,…,Kn}需确定1，2…n的一种排序P1,P2…Pn,使其相应的关键字满足如下的非递减的关系：Kp1≤Kp2≤…≤Kpn,即按关键字{Rp1,Rp2,…,Rpn}有序的排列，这样的一种操作称为排序。一般情况下，排序又分为内部排序和外部排序。而在内部排序中又含有很多排序方法，就其全面性能而言，很难提出一种被认为是最好的方法，因为每一种方法都有它的优缺点，适合在不同的环境下使用。我们学习的排序有:直接插入排序、折半插入排序、希尔排序、快速排序、基数排序、归并排序等。本次课题研究中，我主要进行了二路归并排序的研究和学习。 1.2设计的背景和意义 排序是计算机领域的一类非常重要的问题，计算机在出来数据的过程中，有25%的时间花在了排序上，有许多的计算机设备，排序用去计算机处理数据时间的一半以上，这对于提高计算机的运行速度有一定的影响。此时排序算法的高效率显得尤为重要。 在排序算法汇中，归并排序（Merging sort）是与插入排序、交换排序、选择排序不同的另一类排序方法。归并的含义是将两个或两个以上的有序表组合成一个新的有序表。归并排序可分为多路归并排序，两路归并排序，既可用于内排序，也可以用于外排序。这里仅对内排序的两路归并排序进行讨论。 而我们这里所探究学习的二路归并排序，设计思路更加清晰、明了，程序本身也不像堆结构那样复杂，同时时间复杂度仅为0(N)，同时在处理大规模归并排序的时候，排序速度也明显优于冒泡法等一些排序算法，提高排序算法的效率。 正文 2.1设计内容 设计一个利用二路归并算法实现的排序算法，针对输入的一组无序的数，利用栈或者数组机芯存储，然后进行数据的两两分组、比较，构造新的栈或者数组，依次类推，直到得到一个有序数组或者栈，最后输出有序数据，得到有序数据。 2.2设计要求 假设初始序列含有n 个数据（n是已经确定的数据个数），首先把n 个记录看成n 大连理工大学实验预习报告 学院（系）：电信专业：班级： 姓名：学号：组：___ 实验时间：实验室：实验台： 指导教师签字：成绩： 实验名称Merge sort 一、实验目的和要求 (一)、实验目的 Design the merge sort algorithm and implement it in C language 设计归并排序算法并于C语言实现。 (二)、实验要求 Requirements: 1) Analyze the time complexity of your algorithm 2) Submit the document explaining your algorithm as well as the source code. 要求： 1)分析算法的时间复杂度。 2) 提交的文档中说明你的算法和源代码。 二、实验原理 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可 解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？ 可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。 串行归并与并行归并排序算法 一、串行归并排序算法 归并排序是一种很容易进行并行化的算法，因为归并的各个数据区间都是独立的，没有依赖关系。并且归并排序是一种速度比较快的排序，且是一种稳定的排序算法，排序速度与关键词初始排列无关。 串行归并排序的算法大体的可以描述为：首先将要排序的表分成两个节点个数基本相等的子表，然后对每个子表进行排序，最后将排好序的两个子表合并成一个子表。在对子表进行排序时可以将子表再分解成两个节点数量基本相同的子表，当子表足够小时，也可以采用其他排序方法对子表进行排序，然后再对排好序的子表进行归并操作，最后将整个表排好序。 1、1算法流程图 并行归并排序算法的流程图： 串行归并排序算发流程图 1、2代码分析 #include 归并排序算法解决排序问题 目录 1引言 (2) 2.归并排序的基本思想 (2) 3.归并排序算法不同的方式 (3) 1.归并排序基本算法 (3) 1.实现过程 (3) 2.性能分析： (4) 2.递归二路归并排序 (5) 1.算法过程 (5) 2.性能分析： (6) 3.归并排序算法的改进算法 (7) 1.引理 (7) 2.应用例子 (7) 3.时间复杂性的分析 (8) 4.总结 (9) 5.参考文献 (9) 1引言 从归并排序的概念上进行分析，该算法的思想比较容易理解，并且也能够直观的感知其实质是利用存储空间的归并。在实现的过程中，可以有多种方法，画出归并过程示意图后，随即可以得出其算法的代码。但是我们在利用递归思想实现归并排序的教学程中，一定要让学生分清是用递归还是用回归进行的归并，画出图形区分这两种不同的归并过程。通过这一环节，我们不但能够理解稳定的归并排序，而且还让学生认清递归和回归是解决这一问题两种不同的操作过程。 2.归并排序的基本思想 归并排序主要是二路归并排序，它的基本思想是：设n个数据，初始时把他们看成n 个长度为l的有序子数组，然后从第—个子数组开始，把相邻的子数组两两归并，得到n／2个长度为2的新的有序子数组(当n为奇数是最后—个新的有序子数组长度为1)；对这些新的有序子数组再两两归并；如此重复，直到得到—个长度为n的有序数组为止”。归并排序有两种实现方法：自顶向下和自底向上，前者定义是自底向上， 3.归并排序算法不同的方式 1.归并排序基本算法 1.实现过程 当初次理解归并概念的时候，我们可以列举下列一组数据的归并过程。例如：70 83 100 65 10 32 7 65 9 第一次：【70 83】【65 100】【10 32】【7 65】【9】 第二次：【65 70 83 100】【7 10 32 65】【9】 第三次：【7 10 32 65 65 70 83 100】【9】 第四次：【7 9 10 32 65 65 70 83 100】 具体程序代码如下： 函数：void merge(int e[]，int n) 形参说明：e是已知待排序的数组，n是数组中元素的个数，下标从0开始。void merge(int e[]，int n) { int +p=(int+)malloc(Sizeof(int)+n)；／*开辟一块实现交替归并空间*／ int len=l，f=0；／*len为归并单元宽度，f是一个标识，实现交替归并*／while(1en package com.igo.util.file; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.util.HashSet; import java.util.List; import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; import org.slf4j.Logger; /** * * 外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存， * 需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。* 外部排序最常用的算法是多路归并排序，即将原文件分解成多个能够一次性装人内存的部分， * 分别把每一部分调入内存完成排序。然后，对已经排序的子文件进行归并排序。* @author ZhaoWeikai * Company: * 2010-12-23 下午02:25:00 */ public class MergeSort { private static final Logger log = org.slf4j.LoggerFactory.getLogger(MergeSort.class); /** 拆分大小, 单位:行*/ private static int SPLIT_SIZE = 100000; public static void main(String[] args) throws Exception { List C语言二路归并排序算法写了个二路归并的归并排序小代码，直接贴上来 /* file:quick.cpp author:https://www.360docs.net/doc/c32514755.html, */ #include i++; } while(j<=high) { a[k]=a[j]; k++;j++; } } void MSort(int a[],int low,int high,int b[]) { if(low==high) b[low]=a[low]; else { int mid=(low+high)/2; MSort(a,low,mid,b); MSort(a,mid+1,high,b); Merge(a,low,mid,high,b); } } #include tabg->r[k+t-i]=tabs->r[t]; else for(t=j; t<=v; t++) tabg->r[k+t-j]=tabs->r[t]; } void mergepass(table *tabs,table *tabg,int len) { int i,j,n; n=tabg->length=tabs->length; i=1; while(i<=n-2*len+1) { merge(tabs,tabg,i,i+len-1,i+2*len-1); i=i+2*len; } if(i+len-1归并排序上机题
归并排序算法实现 (迭代和递归)
归并排序实验报告
归并排序算法的基本思想及算法实现示例
归并排序分治策略的设计与实现
第13周内排序第5讲-归并排序
分治算法实验(用分治法实现归并排序算法)
多种排序的并行算法(具体)
多路归并排序 外部排序算法
数据结构课程设计二路归并排序说明书
数据结构实验-归并排序算法
并行归并排序
归并排序算法论文
大文件内容排序,多路归并排序算法
C语言二路归并排序算法
数据结构8645归并排序(非递归算法)