# java实现归并算法

class MergeSort implements SortStrategy

{  private Comparable[] bridge;

/**

*利用归并排序算法对数组obj进行排序

*/

public void sort(Comparable[] obj)

{   if (obj == null

{    throw new NullPointerException("The param can not be null!");

}

bridge
= new Comparable[obj.length];                //初始化中间数组

mergeSort(obj,
0, obj.length - 1);                       //归并排序

bridge
= null

}

/**

*将下标从left到right的数组进行归并排序

*
@param obj　要排序的数组的句柄

*
@param left 要排序的数组的第一个元素下标

*
@param right 要排序的数组的最后一个元素的下标

*/

private void mergeSort(Comparable[] obj, int left, int right)

{    if (left < right)

{     int center = (left + right)/2

mergeSort(obj, left, center);

mergeSort(obj, center
+ 1, right);

merge(obj, left, center, right);

}

}

/**

*将两个对象数组进行归并，并使归并后为升序。归并前两个数组分别有序

*
@param obj 对象数组的句柄

*
@param left 左数组的第一个元素的下标

*
@param center 左数组的最后一个元素的下标

*
@param right 右数组的最后一个元素的下标

*/

private void merge(Comparable[] obj, int left, int center, int right)

{   int mid = center + 1

int third = left;

int tmp = left;

while (left <= center && mid <= right)

{     //从两个数组中取出小的放入中间数组

if (obj[left].compareTo(obj[mid]) <= 0

{      bridge[third++= obj[left++];

}
else

bridge[third
++= obj[mid++];

}

//剩余部分依次置入中间数组

while (mid <= right)

{  bridge[third++= obj[mid++];

}

while (left <= center)

{    bridge[third++= obj[left++];

}

//将中间数组的内容拷贝回原数组

copy(obj, tmp, right);

}

/**

*将中间数组bridge中的内容拷贝到原数组中

*
@param obj 原数组的句柄

*
@param left 要拷贝的第一个元素的下标

*
@param right 要拷贝的最后一个元素的下标

*/

private void copy(Comparable[] obj, int left, int right)

{   while (left <= right)

{   obj[left] = bridge[left];

left
++

}
}

}

The divide-and-conquer paradigm involves three steps at each level of the recursion:
Divide the problem into a number of subproblems.
Conquer the subproblems by solving them recursively. If the subproblem sizes are
small enough, however, just solve the subproblems in a straightforward manner.
Combine the solutions to the subproblems into the solution for the original problem.

The merge sort algorithm closely follows the divide-and-conquer paradigm. Intuitively, it
operates as follows.
Divide: Divide the n-element sequence to be sorted into two subsequences of n/2
elements each.
Conquer: Sort the two subsequences recursively using merge sort.
Combine: Merge the two sorted subsequences to produce the sorted answer.

• 本文已收录于以下专栏：

## 归并排序算法（Merge Sort）的Java实现

• 2017年02月24日 09:48
• 3KB
• 下载

## 利用递归算法实现的归并排序的java程序

• 2013年08月19日 16:16
• 2KB
• 下载

## 分治归并排序算法——Java实现

1、分治法 许多有用的算法在结构上是递归的：为了解决一个给定的问题，算法一次或多次递归地调用其自身以解决紧密相关的若干子问题。这些算法典型地遵循分治法的思想：将原问题分解为几个规模较小但类似于原问题的...

## java实现归并排序算法

1.归并排序算法的思想 归并排序主要是使用了递归排序的算法。采用分治思想的策略。要将一个数组排序，先递归地将它分成两半分别排序，然后将结果归并起来。由于需要将两个数组归并到第三个新的数组中去。所以应...

## 排序算法总结(二)-------选择，堆，冒泡，快速，归并排序（java实现）

• ljheee
• 2017年04月08日 16:54
• 378

## 排序算法之——合并排序/归并排序（Java实现）

• qj30212
• 2016年09月10日 14:58
• 221

举报原因： 您举报文章：java实现归并算法 色情 政治 抄袭 广告 招聘 骂人 其他 (最多只允许输入30个字)