归并排序代码（归并排序C语言代码，结果出不来，哪里错了）

本文目录

• 归并排序C语言代码，结果出不来，哪里错了
• JAVA归并排序算法，有两行代码看不懂
• C语言归并排序代码
• 归并排序的代码纠正
• c语言的归并排序的完整程序
• 归并排序算法是什么
• 用c语言编写归并排序代码，要求易懂，本人只是c语言的初学者，越简单越好
• 如何用C语言编一个归并排序的程序
• C语言 归并排序的完整代码
• 归并排序的示例代码

归并排序C语言代码，结果出不来，哪里错了

void Merge(int a,int low,int mid,int high,int b)
{
int k=low,i=low,j=mid+1;
while(low《high) //这个while没必要吧
另外下面的对a[i]的合并虽然对，但没有保存在a[i]中，仔细分析会发现问题，a[i]永远保持最原始状态，而最后一步合并是对a[i]合并的，所以永远不会有正确结果，可以不用a[i],或不用b[i]
int MergeSort(int a,int low,int high,int b)
{ int mid;
while(low《high)
{
mid=(low+high)/2;
MergeSort(a,low,mid,b);
MergeSort(a,mid+1,high,b);
Merge(a,low,mid,high,b);
break; //没有改变low，high的值会卡死的
}
或者写成
if(low《high)
{
mid=(low+high)/2;
MergeSort(a,low,mid,b);
MergeSort(a,mid+1,high,b);
Merge(a,low,mid,high,b);
}

JAVA归并排序算法，有两行代码看不懂

以var a = [4,2,6,3,1,9,5,7,8,0];为例子。
1.希尔排序。 希尔排序是在插入排序上面做的升级。是先跟距离较远的进行比较的一些方法。
function shellsort(arr){ var i,k,j,len=arr.length,gap = Math.ceil(len/2),temp; while(gap》0){ for (var k = 0; k 《 gap; k++) { var tagArr = ; tagArr.push(arr[k]) for (i = k+gap; i 《 len; i=i+gap) { temp = arr[i]; tagArr.push(temp); for (j=i-gap; j 》-1; j=j-gap) { if(arr[j]》temp){ arr[j+gap] = arr[j]; }else{ break; } } arr[j+gap] = temp; } console.log(tagArr,“gap:“+gap);//输出当前进行插入排序的数组。 console.log(arr);//输出此轮排序后的数组。 } gap = parseInt(gap/2); } return arr; }
过程输出：
[4, 9] “gap:5“ [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [2, 5] “gap:5“ [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [6, 7] “gap:5“ [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [3, 8] “gap:5“ [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [1, 0] “gap:5“ [4, 2, 6, 3, 0, 9, 5, 7, 8, 1] [4, 6, 0, 5, 8] “gap:2“ [0, 2, 4, 3, 5, 9, 6, 7, 8, 1] [2, 3, 9, 7, 1] “gap:2“ [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] “gap:1“ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
由输出可以看到。第一轮间隔为5。依次对这些间隔的数组插入排序。
间隔为5：
[4, 9] “gap:5“ [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [2, 5] “gap:5“ [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [6, 7] “gap:5“ [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [3, 8] “gap:5“ [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [1, 0] “gap:5“ [4, 2, 6, 3, 0, 9, 5, 7, 8, 1] [4, 6, 0, 5, 8] “gap:2“ [0, 2, 4, 3, 5, 9, 6, 7, 8, 1] [2, 3, 9, 7, 1] “gap:2“ [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] “gap:1“ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
间隔为2：
[4, 2, 6, 3, 0, 9, 5, 7, 8, 1] 4 6 0 5 8 2 3 9 7 1
排序后：
[0, 1, 4, 2, 5, 3, 6, 7, 8, 9]
间隔为1：
排序后：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]。
2.快速排序。把一个数组以数组中的某个值为标记。比这个值小的放到数组的左边，比这个值得大的放到数组的右边。然后再递归 对左边和右边的数组进行同样的操作。直到排序完成。通常以数组的第一个值为标记。
代码:
function quickSort(arr){ var len = arr.length,leftArr=,rightArr=,tag; if(len《2){ return arr; } tag = arr; for(i=1;i《len;i++){ if(arr[i]《=tag){ leftArr.push(arr[i]) }else{ rightArr.push(arr[i]); } } return quickSort(leftArr).concat(tag,quickSort(rightArr)); }
3.归并排序。把一系列排好序的子序列合并成一个大的完整有序序列。从最小的单位开始合并。然后再逐步合并合并好的有序数组。最终实现归并排序。
合并两个有序数组的方法：
function subSort(arr1,arr2){ var len1 = arr1.length,len2 = arr2.length,i=0,j=0,arr3=,bArr1 = arr1.slice(),bArr2 = arr2.slice(); while(bArr1.length!=0 || bArr2.length!=0){ if(bArr1.length == 0){ arr3 = arr3.concat(bArr2); bArr2.length = 0; }else if(bArr2.length == 0){ arr3 = arr3.concat(bArr1); bArr1.length = 0; }else{ if(bArr1《=bArr2){ arr3.push(bArr1); bArr1.shift(); }else{ arr3.push(bArr2); bArr2.shift(); } } } return arr3; }
归并排序：
function mergeSort(arr){ var len= arr.length,arrleft=,arrright =,gap=1,maxgap=len-1,gapArr=,glen,n; while(gap《maxgap){ gap = Math.pow(2,n); if(gap《=maxgap){ gapArr.push(gap); } n++; } glen = gapArr.length; for (var i = 0; i 《 glen; i++) { gap = gapArr[i]; for (var j = 0; j 《 len; j=j+gap*2) { arrleft = arr.slice(j, j+gap); arrright = arr.slice(j+gap,j+gap*2); console.log(“left:“+arrleft,“right:“+arrright); arr = arr.slice(0,j).concat(subSort(arrleft,arrright),arr.slice(j+gap*2)); } } return arr; }
排序[4,2,6,3,1,9,5,7,8,0]输出：
left:4 right:2 left:6 right:3 left:1 right:9 left:5 right:7 left:8 right:0 left:2,4 right:3,6 left:1,9 right:5,7 left:0,8 right: left:2,3,4,6 right:1,5,7,9 left:0,8 right: left:1,2,3,4,5,6,7,9 right:0,8
看出来从最小的单位入手。
第一轮先依次合并相邻元素：4,2; 6,3; 1,9; 5,7; 8,0
合并完成之后变成： [2,4,3,6,1,9,5,7,0,8]
第二轮以2个元素为一个单位进行合并：[2,4],[3,6]; [1,9],[5,7]; [0,8],;
合并完成之后变成：[2,3,4,6,1,5,7,9,0,8]
第三轮以4个元素为一个单位进行合并：[2,3,4,6],[1,5,7,9]; [0,8],
合并完成之后变成： [1,2,3,4,5,6,7,9,0,8];
第四轮以8个元素为一个单位进行合并： [1,2,3,4,5,6,7,9],[0,8];
合并完成。 [0,1,2,3,4,5,6,7,8,9];

C语言归并排序代码

void mergeSort(int a,int left,int right)
{
int i;
// 保证至少有两个元素
if(left 《 right)
{
i = (left+right)/2;
mergeSort(a,left,i);
mergeSort(a,i+1,right);
merge(a,left,right);
}
}
void merge(int a,int left,int right)
{
int begin1 = left;
int mid = (left+right)/2 ;
int begin2 = mid+1;
int k=0;
int newArrayLen = right-left+1;
int *b = (int*)malloc(newArrayLen*sizeof(int));
while(begin1《=mid && begin2《=right)
{
if(a[begin1]《=a[begin2])
b[k++] = a[begin1++];
else
b[k++] = a[begin2++];
}
while(begin1《=mid)
b[k++] = a[begin1++];
while(begin2《=right)
b[k++] = a[begin2++];
copyArray(b,a,newArrayLen,left);
free(b);
}
/**
* 复制数组
* source:源数组
* dest:目标数组
* len:源数组长度
* first:目标数组起始位置
*
*/
void copyArray(int source, int dest,int len,int first)
{
int i;
int j=first;
for(i=0;i《len;i++)
{
dest[j] = source[i];
j++;
}
}
void mergeSortTest()
{
int a = {5, 18, 151, 138, 160, 63, 174, 169, 79, 200};
int len = sizeof(a)/sizeof(int);
showArray(a,len);
mergeSort(a,0,len-1);
showArray(a,len);
}

归并排序的代码纠正

void mergesort(int *a, int left, int right)
{
int middle; int tempt[N]={0};
middle=(left + right)/2;
if(left - right== 0) return;
else {
mergesort(a, left, middle);
mergesort(a, middle+1, right);
merge(a+left, a+middle+1, middle-left+1, right-middle,tempt); //第四个参数，也就是第二个参数的长度算错了
copy(a,tempt,left,right-left+1); }
}

c语言的归并排序的完整程序

这个不难:
#include《stdio.h》
// 一个递归函数
void mergesort(int *num,int start,int end);
// 这个函数用来将两个排好序的数组进行合并
void merge(int *num,int start,int middle,int end);
int main()
{
// 测试数组
int num= {12,54,23,67,86,45,97,32,14,65};
int i;
// 排序之前
printf(“Before sorting:\n“);
for (i=0; i《10; i++)
{
printf(“%3d“,num[i]);
}
printf(“\n“);
// 进行合并排序
mergesort(num,0,9);
printf(“After sorting:\n“);
// 排序之后
for (i=0; i《10; i++)
{
printf(“%3d“,num[i]);
}
printf(“\n“);
return 0;
}
//这个函数用来将问题细分
void mergesort(int *num,int start,int end)
{
int middle;
if(start《end)
{
middle=(start+end)/2;
// 归并的基本思想
// 排左边
mergesort(num,start,middle);
// 排右边
mergesort(num,middle+1,end);
// 合并
merge(num,start,middle,end);
}
}
//这个函数用于将两个已排好序的子序列合并
void merge(int *num,int start,int middle,int end)
{
int n1=middle-start+1;
int n2=end-middle;
// 动态分配内存，声明两个数组容纳左右两边的数组
int *L=new int[n1+1];
int *R=new int[n2+1];
int i,j=0,k;
//将新建的两个数组赋值
for (i=0; i《n1; i++)
{
*(L+i)=*(num+start+i);
}
// 哨兵元素
*(L+n1)=1000000;
for (i=0; i《n2; i++)
{
*(R+i)=*(num+middle+i+1);
}
*(R+n2)=1000000;
i=0;
// 进行合并
for (k=start; k《=end; k++)
{
if(L[i]《=R[j])
{
num[k]=L[i];
i++;
}
else
{
num[k]=R[j];
j++;
}
}
delete L;
delete R;
}

归并排序算法是什么

归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置。

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置。

重复步骤3直到某一指针超出序列尾。

将另一序列剩下的所有元素直接复制到合并序列尾。

用c语言编写归并排序代码，要求易懂，本人只是c语言的初学者，越简单越好

//#include《iostream》
//
//using namespace std;
//
//void Guibing(int*arr,int low,int high)
//{
// int m_Begin1 = low;
// int m_End1 = (low+high)/2;
// int m_Begin2 = m_End1+1;
// int m_End2 = high;
//
// int* temp = new int[high-low+1];
// //申请一个这两组的空间
// //要看 只要有一组到结尾就要结束
// int k=0;
// for (;m_Begin1 《= m_End1 && m_Begin2 《= m_End2;k++)
// {
// // 然后找小的往里存
// if (arr[m_Begin1] 《 arr[m_Begin2])
// {
// temp[k] = arr[m_Begin1];
// m_Begin1++;
// }
// else
// {
// temp[k] = arr[m_Begin2];
// m_Begin2++;
// }
// }
//
// //如果第一组没到结尾 顺序存
// while(m_Begin1 《= m_End1)
// {
// temp[k] = arr[m_Begin1];
// k++;
// m_Begin1++;
// }
// //如果第二组没到结尾 顺序存
// while(m_Begin2 《= m_End2)
// {
// temp[k] = arr[m_Begin2];
// k++;
// m_Begin2++;
// }
// //把已经排好序的 temp 放回到原来对应的位置
// for (k = 0;k《high-low+1;k++)
// {
// arr[low+k] = temp[k];
// }
// delete temp;
//}
//
//void Digui(int*arr,int low,int high)
//{
// if (low 《 high)
// {
// int mid = (low+high)/2;
// Digui(arr,low,mid);
// Digui(arr,mid+1,high);
// Guibing(arr,low,high);
// }
//}
//
//int main()
//{
// int arr = {9,11,5,3,17,13,1,17,25,8};
//
// Digui(arr,0,9);
//
// for (int i =0 ;i《10;i++)
// {
// cout 《《 arr[i] 《《 “ “;
// }
//
// system(“pause“);
// return 0;
//}

如何用C语言编一个归并排序的程序

#include “MergeSort.h“
#include 《iostream》
using namespace std;
MergeSort::MergeSort(vector《int》 _list, int _len)
{
list.push_back(0);
link.push_back(0);
for (int i=0; i《_len; i++) {
list.push_back(_list[i]);
link.push_back(0);
}
this-》len = _len;
}
//9 归并排序:递归-----------------------------------------------------------
//具体方法:以merger_link提供链表功能。merger_link[i]对应在有序子序列中
//merger_list[i]后一个结点在原merger_list中的下标；
//merger_link总是表示有序子序列开始的结点在merge_list中的下标；
//st1,st2为两个有序序列的第一个结点；
//将他们归并，并返回其第一个结点的下标，即merger_link
int MergeSort::list_merge(int st1, int st2)
{
int k = 0, i = st1, j = st2;
while (i && j) //当两序列未检测完
if (list[i] 《= list[j]) //将merge_list[i]和merge_list[j]
{ //中小的连接到merger_link[k]后
link[k] = i;
k = i;
i = link[i];
}else
{
link[k] = j;
k = j;
j = link[j];
}
if (!i) link[k] = j; //将剩余未检测完的merge_list
else link[k] = i; //连接到merger_link[k]后
return link;
}
int MergeSort::merge_sort(int left, int right)
{
if (left》=right) return left;
int middle = (left + right)/2;
//对左右两子序列进行归并
return list_merge(merge_sort(left,middle), merge_sort(middle+1,right));
}
void MergeSort::out()
{
int i = link;
int j = 0;
while (i)
{
j++;
cout《《 list[i] 《《“ “;
i = link[i];
if (j%18 == 0) cout 《《endl;
}
cout 《《endl;
}

C语言 归并排序的完整代码

#include 《stdio.h》 

int main()

{int a={1,3,5,7,9},b={2,4,6,8},c;

int i,j,k,n1,n2,n3;

i=j=k=0;

n1=5;

n2=4;

n3=n1+n2;

for(;i《n1&&j《n2;)

if(a[i]《b[j])c[k++]=a[i++];

else c[k++]=b[j++];

for(;i《n1;)c[k++]=a[i++];

for(;j《n2;)c[k++]=b[j++];

for(k=0;k《n3;k++)

printf(“%d “,c[k]);

printf(“\n“);  

return 0;

} 

归并排序的示例代码

归并排序原理
归并排序具体工作原理如下（假设序列共有n个元素）：
将序列每相邻两个数字进行归并操作（merge)，形成floor(n/2)个序列，排序后每个序列包含两个元素
将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素
重复步骤2，直到所有元素排序完毕
示例代码
Go语言 func mergeSort(r int) int {    length := len(r)       if length 《= 1 {        return r     }       num := length / 2    left := mergeSort(r[:num])       right := mergeSort(r[num:])       return merge(left, right)}func merge(left, right int) (result int) {       l, r := 0, 0       for l 《 len(left) && r 《 len(right) {        if left[l] 《 right[r] {                     result = append(result, left[l])                     l++              } else {                     result = append(result, right[r])                     r++              }       }       result = append(result, left[l:]...)       result = append(result, right[r:]...)       return}Java语言 package　algorithm;public　class　MergeSort　{    //　private　static　long　sum　=　0;    /**    　*　《pre》    　*　二路归并    　*　原理：将两个有序表合并和一个有序表    　*　《/pre》    　*　    　*　@param　a    　*　@param　s    　*　第一个有序表的起始下标    　*　@param　m    　*　第二个有序表的起始下标    　*　@param　t    　*　第二个有序表的结束小标    　*　    　*/    private　static　void　merge(int　a,　int　s,　int　m,　int　t)　{        int　tmp　=　new　int[t　-　s　+　1];        int　i　=　s,　j　=　m,　k　=　0;        while　(i　《　m　&&　j　《=　t)　{            if　(a[i]　《=　a[j])　{                tmp[k]　=　a[i];                k++;                i++;            }　else　{                tmp[k]　=　a[j];                j++;                k++;            }        }        while　(i　《　m)　{            tmp[k]　=　a[i];            i++;            k++;        }        while　(j　《=　t)　{            tmp[k]　=　a[j];            j++;            k++;        }        System.arraycopy(tmp,　0,　a,　s,　tmp.length);    }    /**    　*　    　*　@param　a    　*　@param　s    　*　@param　len    　*　每次归并的有序集合的长度    　*/    public　static　void　mergeSort(int　a,　int　s,　int　len)　{        int　size　=　a.length;        int　mid　=　size　/　(len　《《　1);        int　c　=　size　&　((len　《《　1)　-　1);        //　-------归并到只剩一个有序集合的时候结束算法-------//        if　(mid　==　0)            return;        //　------进行一趟归并排序-------//        for　(int　i　=　0;　i　《　mid;　++i)　{            s　=　i　*　2　*　len;            merge(a,　s,　s　+　len,　(len　《《　1)　+　s　-　1);        }        //　-------将剩下的数和倒数一个有序集合归并-------//        if　(c　!=　0)            merge(a,　size　-　c　-　2　*　len,　size　-　c,　size　-　1);        //　-------递归执行下一趟归并排序------//        mergeSort(a,　0,　2　*　len);    }    public　static　void　main(String　args)　{        int　a　=　new　int　{　4,　3,　6,　1,　2,　5　};        mergeSort(a,　0,　1);        for　(int　i　=　0;　i　《　a.length;　++i)　{            System.out.print(a[i]　+　　);        }    }}Python语言 def MergeSort(lists):    if len(lists) 《= 1:        return lists    num = int( len(lists)/2 )    left = MergeSort(lists[:num])    right = MergeSort(lists[num:])    return Merge(left, right)def Merge(left,right):    r, l=0, 0    result=    while l《len(left) and r《len(right):        if left[l] 《 right[r]:            result.append(left[l])            l += 1        else:            result.append(right[r])            r += 1    result += right[r:]    result+= left[l:]    return resultprint MergeSort([1, 2, 3, 4, 5, 6, 7, 90, 21, 23, 45])C语言 #include 《stdlib.h》#include 《stdio.h》void Merge(int sourceArr,int tempArr, int startIndex, int midIndex, int endIndex){    int i = startIndex, j=midIndex+1, k = startIndex;    while(i!=midIndex+1 && j!=endIndex+1)    {        if(sourceArr[i] 》= sourceArr[j])            tempArr[k++] = sourceArr[j++];        else            tempArr[k++] = sourceArr[i++];    }    while(i != midIndex+1)        tempArr[k++] = sourceArr[i++];    while(j != endIndex+1)        tempArr[k++] = sourceArr[j++];    for(i=startIndex; i《=endIndex; i++)        sourceArr[i] = tempArr[i];}//内部使用递归void MergeSort(int sourceArr, int tempArr, int startIndex, int endIndex){    int midIndex;    if(startIndex 《 endIndex)    {        midIndex = (startIndex + endIndex) / 2;        MergeSort(sourceArr, tempArr, startIndex, midIndex);        MergeSort(sourceArr, tempArr, midIndex+1, endIndex);        Merge(sourceArr, tempArr, startIndex, midIndex, endIndex);    }}int main(int argc, char * argv){    int a = {50, 10, 20, 30, 70, 40, 80, 60};    int i, b;    MergeSort(a, b, 0, 7);    for(i=0; i《8; i++)        printf(%d , a[i]);    printf(\n);    return 0;}PHP语言 //merge函数将指定的两个有序数组(arr1arr2,)合并并且排序//我们可以找到第三个数组,然后依次从两个数组的开始取数据哪个数据小就先取哪个的,然后删除掉刚刚取过///的数据functional_merge($arrA,$arrB){    $arrC = array();    while(count($arrA) && count($arrB)){        //这里不断的判断哪个值小,就将小的值给到arrC,但是到最后肯定要剩下几个值,        //不是剩下arrA里面的就是剩下arrB里面的而且这几个有序的值,肯定比arrC里面所有的值都大所以使用        $arrC = $arrA[’0’] 《 $arrB[’0’] ? array_shift($arrA) : array_shift($arrB);    }    returnarray_merge($arrC, $arrA, $arrB);}//归并排序主程序functional_merge_sort($arr){    $len=count($arr);    if($len 《= 1)        return $arr;//递归结束条件,到达这步的时候,数组就只剩下一个元素了,也就是分离了数组    $mid = intval($len/2);//取数组中间    $left_arr = array_slice($arr, 0, $mid);//拆分数组0-mid这部分给左边left_arr    $right_arr = array_slice($arr, $mid);//拆分数组mid-末尾这部分给右边right_arr    $left_arr = al_merge_sort($left_arr);//左边拆分完后开始递归合并往上走    $right_arr = al_merge_sort($right_arr);//右边拆分完毕开始递归往上走    $arr=al_merge($left_arr, $right_arr);//合并两个数组,继续递归    return $arr;}$arr = array(12, 5, 4, 7, 8, 3, 4, 2, 6, 4, 9);print_r(al_merge_sort($arr));Pascal语言 program　mergesort_1;const　maxn=7;type　arr=array[1..maxn]　of　integer;var　a,b,c:arr;i:integer;procedure　merge(r:arr;l,m,n:integer;varr2:arr);var　i,j,k,p:integer;begin　i:=l;　j:=m+1;　k:=l-1;　while　(i《=m)　and　(j《=n)　do　begin　k:=k+1;　if　r[i]《=r[j]　then　begin　r2[k]:=r[i];　i:=i+1　end　else　begin　r2[k]:=r[j];　j:=j+1;　end　end;　if　i《=m　then　for　p:=i　to　m　do　begin　k:=k+1;　r2[k]:=r[p];　end;　if　j《=n　then　for　p:=j　to　n　do　begin　k:=k+1;　r2[k]:=r[p];　end;end;procedure　mergesort(var　r,r1:arr;s,t:integer);var　k:integer;c:arr;begin　if　s=t　then　r1[s]:=r[s]　else　begin　k:=(s+t)div2;　mergesort(r,c,s,k);　mergesort(r,c,k+1,t);　merge(c,s,k,t,r1)　end;end;begin　write(’Enterdata:’);　for　i:=1　to　maxn　do　read(a[i]);　mergesort(a,b,1,maxn);　for　i:=1　to　maxn　do　write(b[i]:9);　writeln;end.//============================================program　mergesort_2;const　max=100000;var　a,r:array[1..max]　of　long　int;n,i:long　int;procedure　msort(s,t:longint);var　m,i,j,k:long　int;begin　if　s=t　then　exit;　m:=(s+t)div2;　msort(s,m);　msort(m+1,t);　i:=s;　j:=m+1;　k:=s;　while　(i《=m)　and　(j《=t)　do　begin　if　a[i]《a[j]　then　begin　r[k]:=a[i];　inc(i);　inc(k);　end　else　begin　r[k]:=a[j];　inc(j);　inc(k);　end;　end;　while　i《=m　do　begin　r[k]:=a[i];　inc(i);　inc(k);　end;　while　j《=t　do　begin　r[k]:=a[j];　inc(j);　inc(k);　end;　for　i:=s　to　t　do　a[i]:=r[i];end;begin　readln(n);　for　i:=1　to　n　do　read(a[i]);　msort(1,n);　for　i:=1　to　n　do　writeln(a[i]);end.Basic语言 Sub MergeSort(Array() As Integer, First As Integer, Last As Integer)Dim mid As Integer = 0If first《last Then mid = (first+last)\ 2MergeSort(Array, first, mid);MergeSort(Array, mid+1, last);Merge(Array, first, mid, last);End IfEnd Sub/*以下示例代码实现了归并操作。array是元素序列，其中从索引p开始到q位置，按照升序排列，同时，从(q+1)到r也已经按照升序排列，merge()函数将把这两个已经排序好的子序列合并成一个排序序列。结果放到array中。*//*** 0 《= p 《= q 《 r, subarray array[p..q] and array[q+1..r] are already sorted.* the merge() function merges the two sub-arrays into one sorted array.*/void Merge(int array, int p, int q, int r){    int i,k;    int begin1,end1,begin2,end2;    int* temp = (int*)malloc((r-p+1)*sizeof(int));    begin1 = p;    end1   = q;    begin2 = q+1;    end2   = r;    k = 0;    while((begin1 《= end1)&&( begin2 《= end2))    {        if(array[begin1] 《= array[begin2]){             temp[k] = array[begin1];            begin1++;        }        else        {            temp[k] = array[begin2];            begin2++;        }        k++;    }    while(begin1《=end1 || begin2《=end2)    {        if(begin1《=end1)        {            temp[k++] = array[begin1++];        }        if(begin2《=end2)        {            temp[k++] = array[begin2++];        }        }        for (i = 0; i 《 =(r - p); i++)            array[p+i] = temp[i];    free(temp);}JavaScript语言
使用递归的代码如下。优点是描述算法过程思路清晰，缺点是使用递归，mergeSort()函数频繁地自我调用。长度为n的数组最终会调用mergeSort()函数 2n-1次，这意味着一个长度超过1500的数组会在Firefox上发生栈溢出错误。可以考虑使用迭代来实现同样的功能。 function　merge(left, right){    var　result=;    while(left.length》0 && right.length》0){        if(left《right){        /*shift()方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。*/            result.push(left.shift());        }else{            result.push(right.shift());        }    }    return　result.concat(left).concat(right);}function　mergeSort(items){    if(items.length == 1){        return　items;}var　middle = Math.floor(items.length/2),    left = items.slice(0, middle),    right = items.slice(middle);    return　merge(mergeSort(left), mergeSort(right));}非递归算法（C++） #include《iostream》#include《ctime》#include《cstring》#include《cstdlib》using namespace std;/**将a开头的长为length的数组和b开头长为right的数组合并n为数组长度，用于最后一组*/void　Merge(int*　data,int　a,int　b,int　length,int　n){　int　right;　if(b+length-1 》= n-1)　right = n-b;　else　right = length;　int*　temp = new　int[length+right];　int　i=0, j=0;　while(i《=length-1 && j《=right-1){    　if(data[a+i] 《= data[b+j]){    　    temp[i+j] = data[a+i];i++;      }    　else{        temp[i+j] = data[b+j];        j++;      }　}　if(j == right){//a中还有元素，且全都比b中的大,a[i]还未使用　  memcpy(temp + i + j, data + a + i, (length - i) * sizeof(int));　}  else if(i == length){      memcpy(temp + i + j, data + b + j, (right - j)*sizeof(int));  }　memcpy(data+a, temp, (right + length) * sizeof(int));　delete  temp;}void　MergeSort(int*　data, int　n){　int　step = 1;　while(step 《 n){    　for(int　i=0; i《=n-step-1; i+=2*step)    　    Merge(data, i, i+step, step, n);    //将i和i+step这两个有序序列进行合并    //序列长度为step    //当i以后的长度小于或者等于step时，退出    　step*=2;//在按某一步长归并序列之后，步长加倍　}}int　main(){　int　n;　cin》》n;　int*　data = new　int[n];　if(!data)　exit(1);　int　k = n;　while(k--){　    cin》》data[n-k-1];　}　clock_t　s = clock();　MergeSort(data, n);　clock_t　e = clock();　k=n;　while(k--){　    cout《《data[n-k-1]《《’ ’;　}　cout《《endl;　cout《《the algorithm used《《e-s《《miliseconds.《《endl;　delete　data;　return　0;}二路归并
ConstFI=’in.txt’;FO=’out.txt’;MaxN=10000;TypeTIndex=Longint;TDat=Array[0..MaxN]OfTIndex;VarN:TIndex;Dat:TDat;Tmp:TDat;ProcedureMerge(L,Mid,R:TIndex);VarP1,P2:TIndex;E1,E2:TIndex;P:TIndex;I:TIndex;BeginP1:=L;P2:=Mid+1;P:=L;RepeatIf(Dat[P1]《=Dat[P2])ThenBeginTmp[P]:=Dat[P1];Inc(P1);Inc(P);EndElseBeginTmp[P]:=Dat[P2];Inc(P2);Inc(P);End;Until(P1=Mid+1)Or(P2=R+1);If(P1=Mid+1)ThenBeginE1:=P2;E2:=R;EndElseBeginE1:=P1;E2:=Mid;End;ForI:=E1ToE2DoBeginTmp[P]:=Dat[I];Inc(P);End;End;ProcedureSort(L,R:TIndex);VarMid:TIndex=0;BeginMid:=(L+R)Shr1;If(L《Mid)ThenSort(L,Mid);If(Mid+1《R)ThenSort(Mid+1,R);Merge(L,Mid,R);ForMid:=LToRDoDat[Mid]:=Tmp[Mid];End;ProcedureInit;VarI:TIndex;BeginFillChar(Dat,SizeOf(Dat),0);Readln(N);ForI:=1ToNDoRead(Dat[I]);End;ProcedureMain;BeginSort(1,N);End;ProcedureFinal;VarI:TIndex;BeginForI:=1ToNDoWrite(Dat[I],’’);Writeln;End;BeginAssign(Input,FI);Assign(Output,FO);Reset(Input);Rewrite(Output);Init;Main;Final;Close(Input);Close(Output);End.
Delphi归并排序完整源代码例子： //合并子函数procedureTForm1.MergePass(vardatas:arrayofInteger;left,mid,right:Integer);vartmpArr:arrayofInteger;arrLen:Integer;i,k:Integer;begin1,begin2,end1,end2:Integer;beginarrLen:=right-left+1;SetLength(tmpArr,arrLen);begin1:=left;end1:=mid;begin2:=mid+1;end2:=right;k:=0;while((begin1《=end1)and(begin2《=end2))dobeginif(datas[begin1]《datas[begin2])thenbegintmpArr[k]:=datas[begin1];Inc(begin1);endelsebegintmpArr[k]:=datas[begin2];Inc(begin2);end;inc(k);end;while(begin1《=end1)dobegintmpArr[k]:=datas[begin1];Inc(begin1);Inc(k);end;while(begin2《=end2)dobegintmpArr[k]:=datas[begin2];Inc(begin2);Inc(k);end;fori:=0to(right-left)dobegindatas[left+i]:=tmpArr[i];end;end;//排序主函数，left是数组左下标，0开始。right是数组右下标。procedureTForm1.MergeSort(vardatas:arrayofInteger;left,right:Integer);varmid:Integer;i:Integer;beginmid:=0;if(left《right)thenbeginmid:=(right+left)div2;showLog(’中间索引：’+inttostr(mid));MergeSort(datas,left,mid);MergeSort(datas,mid+1,right);MergePass(datas,left,mid,right);showLog(’---》’+getArrayString(datas));//显示数组中间状态end;end;//调用方法：procedureTForm1.btn1Click(Sender:TObject);varinArr:array[0..9]ofInteger;beginCopyMemory(@inArr,@CTabls,SizeOf(Integer)*10);showLog(’输入数据：’+getArrayString(inArr));MergeSort(inArr,0,High(inArr));showLog(’输出数据：’+getArrayString(inArr));end;