合并排序算法（merge&sort）的java简单实现
merge sort的核心思想其实有三个部分：
1.分拆：把问题分解成很多子问题。当然分拆的方式很多种，你可以对半拆，3份拆，或者你自己定义一种拆分方法。无论使用哪种方式，需要保证的一个结果是，你必须让每一次递归拆分都能按照这个拆法走下去。
2.解决：解决其实是指，对每一个子问题进行单独的解决（这里最好是用递归的方式，因为这样的话，你可以不用写很多垃圾代码），如果问题已经达到原子级别，则直接求解。
3.合并：合并的意义在于把所有的子问题的结果合并起来，从而得到原问题的答案。
废话不多说，直接上代码：
public class MergeSort implements SortingAlgorithm {
public void sort(int[] source, Order order) {
mergeSort(source, 0, source.length - 1, order);
public void mergeSort(int[] source, int p, int r, Order order)
if (p & r) {
int q = (p + r) / 2;
mergeSort(source, p, q, order);
mergeSort(source, q + 1, r, order);
merge(source, p, q, r, order);
private void merge(int[] source, int p, int q, int r, Order
int left[] = new int[Math.abs(q - p) + 1];
for (int i = 0; i & left. i++) {
left[i] = source[p + i];
int right[] = new int[Math.abs(r - q)];
for (int i = 0; i & right. i++) {
right[i] = source[q + i+1];
if (Order.ASC.equals(order)) {
int i = 0;
int j = 0;
while (i & left.length && j & right.length)
if (left[i] & right[j]) {
source[k] = left[i];
if (i == left.length) {
for (int t = t & right. t++) {
source[k] = right[t];
source[k] = right[j];
if (j == left.length) {
for (int t = t & left. t++) {
source[k] = left[t];
if (Order.DESC.equals(order)) {
int i = 0;
int j = 0;
while (i & left.length && j & right.length)
if (left[i] & right[j]) {
source[k] = left[i];
if (i == left.length) {
for (int t = t & right. t++) {
source[k] = right[t];
source[k] = right[j];
if (j == left.length) {
for (int t = t & left. t++) {
source[k] = left[t];
我们注意到这一段
public void mergeSort(int[] source,
int p, int r, Order order) {
if (p & r) {
int q = (p + r) / 2;
mergeSort(source, p, q,
mergeSort(source, q + 1, r,
merge(source, p, q, r,
并没有出现解决这一阶段，为什么呢，很简单，因为当p&=r的时候只剩一个元素了，这一个元素必然是排好序的。
再看看合并过程的思想，其实也很明了：
1.把待排序的两个数组的东西复制出来一份，很明显，到了原子级别，这个数组肯定是排好序（可能是升序，也可能是降序，这个取决于我们传入的order参数）的，
2.由于这两个数组其实是截取了原数组的某一段，那么我们要做的就是把这两个数组填充到这一段里去
3.去两个数组最左边的一个互相对比，当某一个大或者小（这个规则也是order参数确定的），我们就把它放到待填充的那一段的第一个位置，然后是第二个位置，如此类推
4.当某一个数组已经遍历完了，我们把剩下的数组的东西直接丢到带填充的那一段后面就行了
5.递归执行以上过程
大家想想，其实这个过程也可以用一副牌玩出来，有兴趣可以试试
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Java实现把两个数组合并为一个的方法总结
转载 & & 作者：jaycee110905
这篇文章主要介绍了Java实现把两个数组合并为一个的方法,结合实例形式总结分析了java常用的四种数组合并操作技巧,需要的朋友可以参考下
本文实例讲述了Java实现把两个数组合并为一个的方法。分享给大家供大家参考，具体如下：
在Java中，如何把两个String[]合并为一个？
看起来是一个很简单的问题。但是如何才能把代码写得高效简洁，却还是值得思考的。这里介绍四种方法，请参考选用。
一、apache-commons
这是最简单的办法。在apache-commons中，有一个ArrayUtils.addAll(Object[], Object[])方法，可以让我们一行搞定：
String[] both = (String[]) ArrayUtils.addAll(first, second);
其它的都需要自己调用jdk中提供的方法，包装一下。
为了方便，我将定义一个工具方法concat，可以把两个数组合并在一起：
static String[] concat(String[] first, String[] second) {}
为了通用，在可能的情况下，我将使用泛型来定义，这样不仅String[]可以使用，其它类型的数组也可以使用：
static &T& T[] concat(T[] first, T[] second) {}
当然如果你的jdk不支持泛型，或者用不上，你可以手动把T换成String。
二、System.arraycopy()
static String[] concat(String[] a, String[] b) {
String[] c= new String[a.length+b.length];
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);
使用如下：
String[] both = concat(first, second);
三、Arrays.copyOf()
在java6中，有一个方法Arrays.copyOf()，是一个泛型函数。我们可以利用它，写出更通用的合并方法：
public static &T& T[] concat(T[] first, T[] second) {
T[] result = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, result, first.length, second.length);
如果要合并多个，可以这样写：
public static &T& T[] concatAll(T[] first, T[]... rest) {
int totalLength = first.
for (T[] array : rest) {
totalLength += array.
T[] result = Arrays.copyOf(first, totalLength);
int offset = first.
for (T[] array : rest) {
System.arraycopy(array, 0, result, offset, array.length);
offset += array.
使用如下：
String[] both = concat(first, second);
String[] more = concat(first, second, third, fourth);
四、Array.newInstance
还可以使用Array.newInstance来生成数组：
private static &T& T[] concat(T[] a, T[] b) {
final int alen = a.
final int blen = b.
if (alen == 0) {
if (blen == 0) {
final T[] result = (T[]) java.lang.reflect.Array.
newInstance(a.getClass().getComponentType(), alen + blen);
System.arraycopy(a, 0, result, 0, alen);
System.arraycopy(b, 0, result, alen, blen);
更多关于java相关内容感兴趣的读者可查看本站专题：《》、《》、《》、《》及《》
希望本文所述对大家java程序设计有所帮助。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具1272人阅读
（两个数组各自的长度）
9，6，5，3，1
（第一个数组）
（第二个数组）
1，2，3，4，5，6，7，9
public class Main2 {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int[][] arrays=new int[3][];
for(int i=0;i&arrays.i++){
String str=sc.nextLine();
String[] strArray=str.split(",");
arrays[i]=new int[strArray.length];
for(int j=0;j&strArray.j++){
arrays[i][j]=Integer.parseInt(strArray[j]);
System.out.print(arrays[i][j]+",");
System.out.println();
int[] combineArray = Arrays.copyOf (arrays[1],arrays[1].length+arrays[2].length);
System.arraycopy(arrays[2], 0, combineArray, arrays[1].length, arrays[2].length);
Arrays.sort(combineArray);
for(int num:combineArray){
System.out.print(num+",");
System.out.println();在java编程中如何对数组进行排序，并输出排序后的数组及原数组下标值_百度知道
在java编程中如何对数组进行排序，并输出排序后的数组及原数组下标值
我现在需要取一个无序数组中按照降序排列的前n个值及其在原始数组中的下标位置。n是变量，可取下标范围内的任何数。希望能得到新颖的思路。
我有更好的答案
java变成对数组进行排序可以使用ArraySort方法，保存源数组下标值可以存入map中，如下代码：import&java.util.ArrayLimport&java.util.Aimport&java.util.HashMimport&java.util.Lpublic&class&ceshi&{ public&static&void&main(String[]&args)&{
int&n&=&5;
int[]&a&=&{&8,&5,&4,&6,&2,&1,&7,&9,&3&};
HashMap&map&=&new&HashMap();
for&(int&i&=&0;&i&&&a.&i++)&{
map.put(a[i],&i);&//&将值和下标存入Map
List&list&=&new&ArrayList();
Arrays.sort(a);&//&升序排列
for&(int&i&=&0;&i&&&a.&i++)&{
list.add(a[i]);
for&(Object&object&:&list)&{
System.out.print(object&+&&,&);
System.out.println();
//&查找原始下标
for&(int&i&=&0;&i&&&n;&i++)&{
System.out.print(map.get(a[i])&+&&,&);
} }}运行结果如下：
软件工程师
/逆序排列.add(a[i]);i&}Collections.reverse(list);
&#47.i++){ list,4.i++){ map.put(a[i];a;Arrays.sort(a);
&#47,6;a,2,1.size();i++){ a[i]=(Integer)list,7,i);
/排列List list=new ArrayList(),9;i&n;i++)
{ System,3};HashMap map=new HashMap();for(int i=0;i&/将值和下标存入Map}
///升序排列for(int i=0;i&查找原始下标for(int i=0,变为降序for(int i=0.get(i);}
/&#47.out.println(mapint n=5;int[] a={8,5
本回答被提问者采纳
arrays.sort
写循环就好了
int [] array={.....};Arrays.sort(array); //升序int start=0;int end=array.length-1;while(start&end){ //首尾调换
int num=array[start];
array[start]=array[end];
array[end]=
假设您有一个数组,这个数组的变量可以是任何简单数据类型和对象类型.这里以int为例,代码如下:int[] ages = {4,23,67,12,45,52,33,11,8,80};java.util.Arrays.sort(ages);这样,ages数组中的数据就从小到大排列了.Arrays还支持对该数组中的一段进行排序:java.util.Arrays.sort(ages,3,8);
放到数组里，冒泡排序啦，快速排序啦。好多种方法都可以……
其他2条回答
为您推荐：
其他类似问题
您可能关注的内容
数组 java编程的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。}