java合并排序_剑指OFFER（java）-合并两个已排序的数组

题目：有两个排序的数组A1和A2，内存在A1的末尾有足够多的空余空间容纳A2。请实现一个函数，把A2中的所有数字插入到A1中并且所有的数字是排序的。

java没法像C那样这么定义

int A[100] = { 1, 3, 5, 7, 8, 12};

而且int数组没法自己扩容。。。。。

so，只能另外定义一个数组，如果用C的话

package cglib;

public class List1

{

public static void merge2SortedArray(int[] a , int[] b , int[] c){

//a数组的当前索引

int i = 0;

//b数组的当前索引

int j = 0;

//c数组的当前索引

int k = 0;

//循环，只要a和b都没有遍历完就一直循环

while(i < a.length && j < b.length){

//如果当前a[i]比b[j]小，就把c[k]元素置为a[i],同时k++,i++

if(a[i] < b[j]){

c[k++] = a[i++];

//否则,如果当前a[i]比b[j]大，就把c[k]元素置为b[j],同时k++,j++

}else{

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

}

}

//上个循环能够结束，说明a已经循环完或b已经循环完

//下述两个循环只能有一个满足循环条件

//只要a没有循环完，就把a中剩下的元素依次放入c中

while(i < a.length){

c[k++] = a[i++];

}

//只要b没有循环完，就把b中剩下的元素依次放入c中

while(j < b.length){

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

}

}

//测试程序

public static void main(String[] args) {

//待合并数组a

int[] a = new int[]{1,3,5,7,9};

//待合并数组b

int[] b = new int[]{2,4,6,8};

//c用来存放合并之后的数组

int[] c = new int[a.length+b.length];

merge2SortedArray(a, b, c);

for(int i = 0;i < c.length;i++){

System.out.print(c[i]+"\t");

}

}

}

输出：

1    2    3    4    5    6    7    8    9

用C++的话：

//思路1：设置两个索引indexofA1,indexofA2分别指向数组A1和A2的最后一个元素，即两个数组的尾部；

//比较两个索引指向的元素的大小:若indexofA1指向的元素(即A1[indexofA1])大于indexofA2指向的元素(即 A2[indexofA2])， 则将indexofA1指向的元素拷贝到临时数组Temp中(Temp从后往前拷贝),  然后indexofA1向前 移动一个位置，然后再将indexA1指向的元素与indexofA2指向的元素进行比较；若indexofA1指向的元素小于indexofA2所指向 的元素，则将indexofA2指向的元素拷贝到临时数组，indexofA2--,然后再将indexA2指向的元素与indexofA1指向的元素进 行比较；若indexofA1指向的元素和indexofA2指向的元素相等，则将这两个元素都拷贝到数组Temp中，然后 indexofA1--,indexofA2--；以此类推，直到数组A1和A2的元素全部拷贝到数组Temp中， 最后将数组Temp中的全部元素依次复制数组A1中。这里用到了辅助内存temp[]

代码

//思路：设置两个索引indexofA1,indexofA2分别指向数组A1和A2的最后一个元素，即两个数组的尾部；

//比较两个索引指向的元素的大小:若indexofA1指向的元素(即A1[indexofA1])大于indexofA2指向的元素(即A2[indexofA2])，

//                                 则将indexofA1指向的元素拷贝到临时数组Temp中,然后indexofA1向前移动一个位置，然后再将indexA1指向的元素与indexofA1指向的元素进行比较

//

//                             若indexofA1指向的元素小于indexofA2所指向的元素，则将index

//

#include

using namespace std;

#define A1length 4

#define A2length 5

void Array_Merge(int A1[],int n1,int A2[],int n2)//n1,n1分别为数组A1和A2中实际元素的数目

{

if(A1==NULL || A2==NULL || n1<=0 ||n2<=0)

{

cout<

return ;

}

int totallength=n1+n2-1;

int indexofA1=n1-1;

int indexofA2=n2-1;

int *Temp=(int *)malloc(sizeof(int)*(n1+n2));

if(Temp==NULL)

{

cout<

return;

}

while(indexofA1>=0 && indexofA2>=0 )//

{

if(A2[indexofA2]>A1[indexofA1])

{

Temp[totallength--]=A2[indexofA2];

indexofA2--;

}

else if(A2[indexofA2]

{

Temp[totallength--]=A1[indexofA1];

indexofA1--;

}

else

{

Temp[totallength--]=A1[indexofA1];

Temp[totallength--]=A2[indexofA2];

indexofA1--;

indexofA2--;

}

}

while(indexofA2>=0)//考虑A1的索引indexofA1先变为-1，此时A1的元素已经全部拷贝到数组Temp中，

//此后只需将A2的剩余元素依次拷贝到数组Temp中；

{

Temp[totallength--]=A2[indexofA2];

indexofA2--;

}

//cout<

while(indexofA1>=0)//考虑A2的索引indexofA2先变为-1，此时A2的元素已经全部拷贝到数组Temp中，

//此后只需将A1的剩余元素依次拷贝到数组Temp中；

{

Temp[totallength--]=A1[indexofA1];

indexofA1--;

}

//cout<

for(int i=0;i<=n1+n2-1;i++)

{

A1[i]=Temp[i];

}

}

int main(void)

{

int A1[10];

int A2[5];

int i;

cout<

for(i=0;i

cin>>A1[i];

cout<

for(i=0;i

cin>>A2[i];

Array_Merge(A1,A1length, A2,A2length);

for(i=0;i

{

cout<

}

cout<

return 0;

}

思路2：利用归并排序中的归并思想，开始时indexofA1和indexofA2两个索引分别指向数组A1和A2的首元素，若 A1[indexofA1]<=A2[indexofA2]时，将indexofA1指向元素赋给辅助数组temp[],再将indexofA1向 后移动一个位置，若A1[indexofA1]>A2[indexofA2]时，将indexofA2指向元素赋给辅助数组temp[],再将 indexofA2向后移动一个位置，如此循环，由于两个数组大小可能不同，因此总会有一个数组会首先操作结束，即其索引指向该数组的尾部，此时只需将另 一个数组的元素全部依次赋给辅助数组即可，最后将辅助数组temp[]的元素重新赋值给数组A1[],就完成了所有操作。

代码：

#include

#include

#include

using namespace std;

void Array_Merge(int A1[],int n1,int A2[],int n2)//n1,n1分别为数组A1和A2中实际元素的数目

{

if(A1==NULL || A2==NULL || n1<=0 ||n2<=0)

{

cout<

return ;

}

int totallength=n1+n2-1;

int indexofA1=0;

int indexofA2=0;

int indexoftemp=0;

int A1end=n1-1;

int A2end=n2-1;

int *Temp=(int *)malloc(sizeof(int)*(n1+n2));

if(Temp==NULL)

{

cout<

return;

}

while(indexofA1<=A1end && indexofA2<=A2end )//

{

if(A1[indexofA1]<=A2[indexofA2])

{

Temp[indexoftemp++]=A1[indexofA1++];

}

else

{

Temp[indexoftemp++]=A2[indexofA2++];

}

}

while(indexofA1<=A1end)

{

Temp[indexoftemp++]=A1[indexofA1++];

}

while(indexofA2<=A2end)

{

Temp[indexoftemp++]=A2[indexofA2++];

}

for(int i=0;i<=totallength;i++)

{

A1[i]=Temp[i];

}

}

int main(void)

{

int A1length,A2length;

int i;

cout<

cin>>A1length>>A2length;

int *A1=(int *)malloc(sizeof(int)*(A1length+A2length));

int *A2=(int *)malloc(sizeof(int)*A2length);

cout<

for(i=0;i

cin>>A1[i];

cout<

for(i=0;i

cin>>A2[i];

Array_Merge(A1,A1length, A2,A2length);

cout<

for(i=0;i

{

cout<

}

cout<

return 0;

}