归并排序算法实现 (迭代和递归)

归并排序算法实现（迭代和递归）\递归实现归并排序的原理如下：

递归分割:

递归到达底部后排序返回:

最终实现排序：

#include

void merge(int *array, int low, int center, int high) {

if(low >= high) return;

int m = center - low + 1;

int n = high - center;

int L[m], R[n];

for(int i=0; i

for(int i=0; i

int i,j,k;

for(i=0,j=0,k=low; i

if(L[i] > R[j])

array[k] = R[j++];

else

array[k] = L[i++];

}

while(i

while(j

}

void m_sort(int *array, int low, int high)

{

int center;

if(low < high) {

center = (low + high)/2;

m_sort(array, low, center);

m_sort(array, center+1, high);

merge(array, low, center, high);

}

}

int main()

{

int array[] = {23, 2, 45, 78, 1, 99, 3};

m_sort(array, 0, 6);

for(int i=0; i<=6; ++i) {

printf("%d\n", array[i]);

}

return 0;

}

时间复杂度：最坏和平均时间复杂度均为O(nlogn)

空间复杂度：上面的实现有些问题，如果真如上面实现，在函数merge中都要使用辅助函数L[m]和R[n]，那么归并了logn层，每层消耗空间O(n)，则实际消耗O(nlogn),再加上栈空间的消耗O(longn),总的消耗为O(nlogn+logn).该算法不符合空间复杂度为O(n)的要求，所以需要修改，实现如下：

#include

#include

using std::string;

void merge(int *array, int *extra, int low, int center, int high) {

memcpy(extra+low, array+low, (high-low+1)*sizeof(int)); int i,j,k;

for(i=low,j=(center+1),k=low; i<=center && j<=high;++k) { if(extra[i] > extra[j])

array[k] = extra[j++];

else

array[k] = extra[i++];

}

while(i<=center) array[k++] = extra[i++];

while(j<=high) array[k++] = extra[j++];

}

void m_sort(int *array, int *extra, int low, int high)

{

int center;

if(low < high) {

center = (low + high)/2;

m_sort(array, extra, low, center);

m_sort(array, extra, center+1, high);

merge(array, extra, low, center, high);

}

}

int main()

{

int array[7] = {23, 2, 45, 78, 1, 99, 3};

int extra[7];

m_sort(array, extra, 0, 6);

for(int i=0; i<=6; ++i) {

printf("%d\n", array[i]);

}

return 0;

}

空间复杂度：使用了辅助数组extra，消耗辅助空间O(n)，加上栈空间的消耗O(logn)，总的空间复杂度为

O(n+logn),如果n无限大，则空间复杂度可以简化为O(n)。

归并排序的迭代实现的原理如下：

实现程序如下：

#include

#include

using std::string;

void merge(int *sort, int *list, int low, int center, int high)

{

int i,j,k;

for(i=low,j=(center+1),k=low; i<=center && j<=high;++k) {

if(list[i] > list[j])

sort[k] = list[j++];

else

sort[k] = list[i++];

}

while(i<=center) sort[k++] = list[i++];

while(j<=high) sort[k++] = list[j++];

}

void merge_pass(int *a, int *b, int length, int n) {

int i;

for(i=0; i<=n-2*length; i+=2*length) {

int center = (i + i + 2*length - 1)/2;

merge(a, b, i, center, i+2*length-1);

}

if((i+length)

int center = (i + i + 2*length - 1)/2;

merge(a, b, i, center, n-1);

} else {

while(i

a[i] = b[i];

++i;

}

}

}

void m_sort(int *array, int n)

{

int extra[n];

int length = 1;

while(length < n) {

merge_pass(extra, array, length, n);

length *= 2;

merge_pass(array, extra, length, n);

length *= 2;

}

}

int main()

{

int data[] = {34, 23, 12, 55, 66, 4, 2, 99, 1, 45, 77, 88, 99, 5};

m_sort(data, 14);

for(int i=0; i<14; ++i) {

printf("%d ", data[i]);

}

printf("\n");

return 0;

}

时间复杂度为：O(nlogn)

空间复杂度为：这里的空间复杂度仅为所需的辅助空间，不需栈空间，为O(n)。

算法设计实验一归并排序(分治)和插入排序的比较分析

沈阳化工大学实验报告 课程名称算法设计与分析 项目名称归并排序(分治)和插入排序的比较 学院应用技术学院 专业计中职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++ } }

C (++)内部排序汇总(快速排序&冒泡排序&堆排序&选择排序&插入排序&归并排序)

#include #include #include #include #define M 30001 random(int a[30001]) { int i; for(i=1;i<30001;i++) a[i]=rand()%30001; }//随机生成30000个数函数 int change1(char a[81]) { int b=0,n,i; for(i=0;a[i]!=0;i++); n=i-1; for(;i>1;i--) b+=((int)pow(10,n+1-i))*(a[i-1]-48); if(a[0]=='-') b=b*(-1); else b+=((int)pow(10,n))*(a[0]-48); return b; }//字符转化成整型 insort(int a[30001]) { int i,j,temp,temp1,n; int count=0; n=30001; for(i=1;i=0;j--)/* 每次循环完毕数组的0到i-1项为一个有序的序列*/ { count=0;/*这里count是标记位，可以减少比较次数*/ if(a[j]>temp) { temp1=a[j+1]; a[j+1]=a[j]; a[j]=temp1;

count++; }//满足条件，前移 if(count==0) break;//位置恰当，退出 } } }//insort插入排序函数 selsort(int a[30001]) { int i,j,temp; for(i=1;i<30000;i++) for(j=i+1;j<30001;j++) if(a[i]>a[j]) { temp=a[j]; a[j]=a[i]; a[i]=temp; } }//选择排序 bubsort(int a[30001]) { int i,j,temp; for(i=1;i<30001;i++) for(j=30000;j>i;j--) { if(a[j-1]>a[j]) { temp=a[j-1]; a[j-1]=a[j]; a[j]=temp; } } }//冒泡排序 int partition(int a[30001],int low,int high)

简单的归并排序算法例子

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 2.typedef int RecType;//要排序元素类型 3.void Merge(RecType *R,int low,int m,int high) 4.{ 5.//将两个有序的子文件R[low..m)和R[m+1..high]归并成一个有序的子文件 R[low..high] 6.int i=low,j=m+1,p=0; //置初始值 7. RecType *R1; //R1是局部向量 8. R1=(RecType *)malloc((high-low+1)*sizeof(RecType)); 9.if(!R1) 10. { 11.return; //申请空间失败 12. } 13.while(i<=m&&j<=high) //两子文件非空时取其小者输出到R1[p]上 14. { 15. R1[p++]=(R[i]<=R[j])?R[i++]:R[j++]; 16. } 17.while(i<=m) //若第1个子文件非空，则复制剩余记录到R1中 18. { 19. R1[p++]=R[i++]; 20. } 21.while(j<=high) //若第2个子文件非空，则复制剩余记录到R1中 22. { 23. R1[p++]=R[j++]; 24. } 25.for(p=0,i=low;i<=high;p++,i++) 26. { 27. R[i]=R1[p]; //归并完成后将结果复制回R[low..high] 28. } 29.} 30.void MergeSort(RecType R[],int low,int high) 31.{ 32.//用分治法对R[low..high]进行二路归并排序 33.int mid; 34.if(low

归并排序算法实现 (迭代和递归)

归并排序算法实现（迭代和递归）\递归实现归并排序的原理如下： 递归分割: 递归到达底部后排序返回: 最终实现排序： #include void merge(int *array, int low, int center, int high) { if(low >= high) return; int m = center - low + 1; int n = high - center; int L[m], R[n]; for(int i=0; i R[j]) array[k] = R[j++]; else array[k] = L[i++];

} while(i #include

归并排序实验报告

篇一：归并排序与快速排序实验报告 一、实验内容： 对二路归并排序和快速排序对于逆序的顺序数的排序时间复杂度比较。 二、所用算法的基本思想及复杂度分析： 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

第13周内排序第5讲-归并排序

归并排序是多次将相邻两个或两个以上的有序表合并成一个新的有序表。 最简单的归并是将相邻两个有序的子表合并成一个有序的表，即二路归并排序。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 #include #include using namespace std; void merge(int A[],int B[],int low,int mid,int high) //将两个子序列合并，排序成一个有序的序列 { int i=low; int j=mid+1; int k=low; while((i<=mid)&&(j<=high)) //两两比较，将较小的数放在临时的数组中{ if(A[i]<=A[j]) { B[k++]=A[i++]; } else { B[k++]=A[j++]; } } if(i>mid) //如果最后左半边子序列已经全部排完，就将右边子序列剩下的元素直接复制到临时的数组中 { for(int last=j;last<=high;last++) { B[k++]=A[last]; } } else//如果最后右半边子序列已经全部排完，就将左边子序列剩下的元素直接复制到临时的数组中

{ for(int last=i;last<=mid;last++) { B[k++]=A[last]; } } } void mergesort(int a[],int b[],int left,int right) //分治法实现归并排序，利用递归实现{ if(left>n; ran(a,n); //生成数组

多路归并排序 外部排序算法

关于多路归并排序外部排序败者树技术积累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引言 (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=n)s end=n一1; ／*确定真正末下标位置*／ merg_step(e，a，f_s，f_s+len-1，s_end)；／*实现将两个单元合并*／

大文件内容排序,多路归并排序算法

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 list = FileUtil.listFiles("E:\\log\\test"); mergeFile(list, "e:/log/testMergeSort.txt"); } public static boolean mergeSort(List originFileList, String outPutFilePath, String tempPath) throws Exception { https://www.wendangku.net/doc/1b15841789.html,("mergeSort start............................................."); FileUtil.createDir(tempPath); if (originFileList == null || originFileList.size() == 0) {

数据结构之归并排序

算法与数据结构实验报告 实验六 实验名称:归并排序问题 姓名：XXX 学号：xxxxxxxxxx 专业：软件工程 班级：x班 指导教师：xxx 日期: 2013年X月X日

一、实验目的 了解归并排序的排序思想，对于给定的关键字序列进行归并排序输出。二、实验内容与实验步骤 内容：设计二路归并算法。 问题描述如下：输入数据第1行有1整数k，表示需要排序的序列个数。以下k行，每行第一个整数m，表示待排序序列的长度，后面的m个整数表示待排序序列。将k个待排序序列的归并排序结果分k行输出。 步骤： 1将一维数组中前后相邻的两个有序序列归并为一个有序序列； 其算法为：void merge(dataList& L, dataList& L1,int left, int mid, int right){}； 2 对顺序表L作归并排序； 其算法为：void MergePass (dataList& L, dataList& L1, int len){}； 3 将SR[s..t]归并为排序为TR1[s..t]； 其算法为：void MergeSort (dataList& L){}； 4 调试数据，程序结束； 三、实验环境 操作系统winXP、开发平台:Microsoft Visual C++6.0 四、实验过程与分析 归并排序算法大大缩短了排序的时间复杂度，虽然程序代码复杂，但实现的基理相当简单。从运行结果可知，该程序达到了预期效果。 五、实验结论 测试数据：测试结果： 3 7 49 38 65 97 76 13 27 13 27 38 49 65 76 97 10 36 25 48 12 65 25 43 58 76 32 12 25 25 32 36 43 48 58 65 76 6 12 32 49 58 65 79 12 32 49 58 65 79 运行结果：

C语言二路归并排序算法

C语言二路归并排序算法写了个二路归并的归并排序小代码，直接贴上来 /* file:quick.cpp author:https://www.wendangku.net/doc/1b15841789.html, */ #include using namespace std; void Merge(int a[],int low,int mid,int high,int b[]); void MSort(int a[],int low,int high,int b[]); void main() { int a[]={4,5,9,10,51,6,46,36,6,56,67,45,36}; int b[13]; MSort(a,0,12,b); for(int i=0;i<13;i++) cout<

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); } }

数据结构8645归并排序(非递归算法)

#include #define MAXSIZE 100 typedef int Keytype; typedef struct { Keytype key; } recordtype; typedef struct { recordtype r[MAXSIZE+1]; int length; } table; void visit(table *t) { int i; for(i=1; i<=t->length; i++) printf("%d ",t->r[i].key); } void merge(table *tabs,table *tabg,int u,int m,int v) { int i,j,k,t; i=u; j=m+1; k=u; while(i<=m&&j<=v) { if(tabs->r[i].key<=tabs->r[j].key) { tabg->r[k]=tabs->r[i]; i++; } else { tabg->r[k]=tabs->r[j]; j++; } k++; } if(i<=m) for(t=i; t<=m; t++)

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-1r[j]=tabs->r[j]; } void mergesort(table *tab) { int len; table temp; len=1; while(lenlength) { mergepass(tab,&temp,len); visit(&temp); printf("\n"); len=2*len; *tab=temp; } } int main() { int i; table tab; scanf("%d",&tab.length); for(i=1; i<=tab.length; i++)