剑指offer+面试题5的相关题目-合并两个有序数组(java解答)

给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

输出: [1,2,2,3,5,6]

import java.util.Arrays;

public class Solution {
	/*
	 * 从头到尾归并
	 * 时间复杂度：O(M + N)O(M+N)，这里 MM 是数组 nums1 的长度，NN 是数组 nums2 的长度。
	 * 空间复杂度：O(M)O(M)，这里 MM 是 nums1 的长度。
	 */
	public static void merge0(int[] nums1,int m,int[] nums2,int n)
	{
		int[] nums3=new int[m];
		//把nums1的有效个元素复制到nums3
		System.arraycopy(nums1, 0, nums3, 0, m);
		int i=0;//数组3
		int j=0;//数组2
		//从前向后归并，比较nums3和nums2前端元素，较小的出列，覆盖nums1
		for(int k=0;k<m+n;k++)
		{
			//注意把nums1和nums2归并完成的逻辑写在前面，否则会出现下标越界
			if(i==m) {
				nums1[k]=nums2[j];
				j++;
			}else if(j==n){
				nums1[k]=nums3[i];
				i++;
			}else if(nums3[i]<nums2[j]) {
				nums1[k]=nums3[i];
				i++;
			}else {
				nums1[k]=nums2[j];
				j++;
			}
		}
	}
	
	/*
	 * 从尾到头归并（更省空间，可以提前终止归并）
	 */
	public static void merge1(int[] nums1,int m,int[] nums2,int n)
	{
		int len=m+n;
		int i=m-1;
		int j=n-1;
		//从后向前归并，比较nums1和nums2末尾元素哪个大，谁大谁出列，覆盖nums1
		for(int k=len-1;k>=0;k--) {
			if(i==-1) {
			//注意把nums1和nums2归并完成的逻辑写在前面，否则会出现下标越界
			//此时j位于数组nums2的末尾索引位置，还未看的数组nums2的长度为j+1
			//复制完break即可
			System.arraycopy(nums2, 0, nums1, 0, j+1);
			break;
			}else if(j==-1) {
				//nums2遍历完后，nums1剩下的元素一定是排后的样子
				break;
			}else if(nums1[i]>=nums2[j]) {
				//谁大谁出列
				nums1[k]=nums1[i];
				i--;
			}else {
				assert nums1[i]<nums2[j];
				nums1[k]=nums2[j];
				j--;
			}			
		}		
	}

    public static void main(String[] args) {
    	int[] a1= {1,3,5,7,0,0,0,0};
    	int[] a2= {2,4,6,8};
    	merge0(a1,4,a2,4);
    	System.out.println(Arrays.toString(a1));
    }    
}

数组与其他种类的容器

区别有三方面：效率、类型和保存基本类型的能力

Java中，数组是一种效率最高的存储和随机访问对象引用序列的方式

• 数组是一个简单的线性序列，这使得元素访问非常快速。
• 付出的代价是数组对象的大小被固定，并且在其生命周期中不可改变。

数组可以创建一个数组去持有某种具体类型，因此优于泛型之前的同期。然而，解决更一般化的问题，数组可能会受到过多的限制

• 在泛型之前，其他的容器在处理对象时，都将这些对象当做Java中根类的根类Object处理
• 有了泛型后，容器可以指定有并检查它们所持对象的类型，并且有了自动包装机制，容器看起来还能够持有基本类型

随着自动包装机制的出现，容器已经可以与数组几乎一样方便的用于基本类型中了

动态数组

t类是JAVA.LANG包中的顶层超类，可以与所有类型兼容，可以将任何t类型添加数至属于t类型的组中，能添加t类型的的集合有ArrayList、Vector及LinkedList，属于集合类。特点有：

• 容量扩充性
• 同步性
• 数据操作效率

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Solution {
	public static void mergeSortArray(List<Integer> a1,List<Integer> a2)
	{
		int length=a1.size()+a2.size();
		
		int i2=length-1;
		int i1=a1.size()-1;
		int j=a2.size()-1;
		for(int i=0;i<a2.size();i++)
			a1.add(a2.get(i));
		
		while(i1>=0&&j>=0)
		{
			if(a1.get(i1)>a2.get(j))
			{
				a1.set(i2, a1.get(i1));
				--i1;
			}
			else
			{
				a1.set(i2, a2.get(j));
				--j;
			}
			--i2;
		}
		
		while(j>=0)
		{
			a1.set(i2--, a2.get(j--));
		}
	}
	
    public static void main(String[] args) {
    	int[] a1= {1,3,5,7};
    	int[] a2= {2,4,6,8};
    	List<Integer> res1 = Arrays.stream(a1).boxed().collect(Collectors.toList());
    	List<Integer> res2 = Arrays.stream(a2).boxed().collect(Collectors.toList());
    	mergeSortArray(res1,res2);
    	System.out.println("list = "+res1);
    }    
}