劍指OFFER（java）-合併兩個已排序的數組

時間 2019-11-19

原文原文鏈接

題目：有兩個排序的數組A1和A2，內存在A1的末尾有足夠多的空餘空間容納A2。請實現一個函數，把A2中的全部數字插入到A1中而且全部的數字是排序的。java

java無法像C那樣這麼定義ios

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

輸出：排序

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[]ci

代碼

//思路：設置兩個索引indexofA1,indexofA2分別指向數組A1和A2的最後一個元素，即兩個數組的尾部；
//比較兩個索引指向的元素的大小:若indexofA1指向的元素（即A1[indexofA1])大於indexofA2指向的元素(即A2[indexofA2])，
// 則將indexofA1指向的元素拷貝到臨時數組Temp中,而後indexofA1向前移動一個位置，而後再將indexA1指向的元素與indexofA1指向的元素進行比較
//
// 若indexofA1指向的元素小於indexofA2所指向的元素，則將index
//
#include<iostream>
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<<"invalid parameter!"<<endl;
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<<"insufficient memory!"<<endl;
return;
}
while(indexofA1>=0 && indexofA2>=0 )//
{
if(A2[indexofA2]>A1[indexofA1])
{
Temp[totallength--]=A2[indexofA2];
indexofA2--;
}
else if(A2[indexofA2]<A1[indexofA1])
{
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<<"indexofA2:"<<indexofA2+1<<endl;
while(indexofA1>=0)//考慮A2的索引indexofA2先變爲-1，此時A2的元素已經所有拷貝到數組Temp中，
//此後只需將A1的剩餘元素依次拷貝到數組Temp中；
{
Temp[totallength--]=A1[indexofA1];
indexofA1--;
}
//cout<<"indexofA1:"<<indexofA1+1<<endl;
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<<"input the array A1:"<<endl;
for(i=0;i<A1length;i++)
cin>>A1[i];
cout<<"input the array A2:"<<endl;
for(i=0;i<A2length;i++)
cin>>A2[i];
Array_Merge(A1,A1length, A2,A2length);
for(i=0;i<A1length+A2length;i++)
{
cout<<A1[i]<<" ";
}
cout<<endl;
return 0;
}

思路2：利用歸併排序中的歸併思想，開始時indexofA1和indexofA2兩個索引分別指向數組A1和A2的首元素，若 A1[indexofA1]<=A2[indexofA2]時，將indexofA1指向元素賦給輔助數組temp[],再將indexofA1向後移動一個位置，若A1[indexofA1]>A2[indexofA2]時，將indexofA2指向元素賦給輔助數組temp[],再將 indexofA2向後移動一個位置，如此循環，因爲兩個數組大小可能不一樣，所以總會有一個數組會首先操做結束，即其索引指向該數組的尾部，此時只需將另一個數組的元素所有依次賦給輔助數組便可，最後將輔助數組temp[]的元素從新賦值給數組A1[],就完成了全部操做。

代碼：