java两个有序数组

㈠ java怎么把两个从小到大排序的一维数组合并成一个从小到大排序的一维数组 求代码和详细解释 万分感谢

public static void main(String[]args)
{
//创建数组
String[] a = { "0", "3", "2", "1" };
String[] b = { "8", "7", "6", "5", "4" };
String[] c = new String[a.length + b.length];
//复制数据
System.array(a, 0, c, 0, a.length);
System.array(b, 0, c, a.length, b.length);
//利用 Arrays排序
Arrays.sort(c);
//遍历展示数据
for(String _var : c)
{
System.out.println(_var);
}
}

基本思路就是这样..先合并 然后排序 然后输出..
希望能够帮助到你.. 合并的时候还有其他的方法..有兴趣你可以去了解下 ~~

㈡ JAVA程序，定义两个不同的数组分别用不同的方法进行排序！谢谢！

这个不是发过了吗？？
int[] a=new int[]{1,2,3,4,5};
int[] b=a;
//int[] b =new int[]{1,2,3,4,5};测试
//int[] b =new int[]{1,2,6,3};测试
if(a.equals(b)){//直接用equals判断地址。地址一样即相等
System.out.println("两个数组相等");
}
Arrays.sort(a);//通过sort方法。是按降序排序的。升序可以排序完逆序输出
for(int i=a.length-1;i>=0;i--){
System.out.println(a[i]);
}

//通过二分查找。找到返回下标位置，找不到返回一个随机负数
int num=Arrays.binarySearch(a, 8);
System.out.println(num);
boolean isExists=(Arrays.binarySearch(a, 8)>=0)?true:false;
if(isExists){
System.out.println("存在！");
}

㈢ java合并两个有序数组

package com.lili.test;

import java.util.Random;
import java.util.Arrays;
/**]
* 合并两数组为一个有序数组
* @作者: lili
* @日期: Nov 9, 2009
*/
public class TestMe {

/**
* @param args
* @throws ParseException
*/
public static void main(String[] args) {

int a[] = new int[6];
int b[] = new int[6];
Random r = new Random();
for (int i = 0; i < a.length; i++) {
a[i] = r.nextInt(100);
}
for (int i = 0; i < b.length; i++) {
b[i] = r.nextInt(100);
}
System.out.println("合并前--------------------------------------");
for (int i = 0; i < a.length; i++) {
System.out.print("A[" + i + "] = " + a[i]+"\t");
}
System.out.println();
for (int i = 0; i < b.length; i++) {
System.out.print("B[" + i + "] = " + b[i]+"\t");
}
System.out.println();
System.out.println("合并前--------------------------------------");
int[] c = concatArray(a, b);
System.out.println("合并后大小：" + c.length);
for (int i = 0; i < c.length; i++) {
System.out.print("c[" + i + "] = " + c[i]+"\t");
if (i % 3 == 0 && i!=0) {
System.out.println();
}
}
}

/**
* 合并两个 int[]型数组为一个有序数组(升序)
*
* @param aArray
* @param bArray
* @return
*/
public static int[] concatArray(int[] aArray, int[] bArray) {
int[] cArray = null;
/*
* 保证参数的合法证
*/
if (aArray == null || bArray == null) {
return aArray == null ? bArray : aArray;
}
if (aArray != null && bArray != null) {
cArray = new int[aArray.length + bArray.length];
}
/*
* 合并前排序
*/
Arrays.sort(aArray);
Arrays.sort(bArray);
/*
* 各数组 的当前 index
*/
int aArray_index = 0;
int bArray_index = 0;
/*
* 开始合并
*/
for (int i = 0; i < cArray.length; i++) {
if (aArray_index > aArray.length - 1
|| bArray_index > bArray.length - 1) {
break;
} else {
int a = aArray[aArray_index];
int b = bArray[bArray_index];

if (a == getMin(a, b)) {
aArray_index++;

cArray[i] = a;
} else {
bArray_index++;
cArray[i] = b;
}
}
}
/*
* 其中一个数组被合并完毕
*/
if (aArray_index < aArray.length - 1) {
for (int i = aArray_index + bArray.length; i < cArray.length; i++) {
cArray[i] = aArray[aArray_index++];
}
} else if (bArray_index < bArray.length - 1) {
for (int i = bArray_index + aArray.length; i < cArray.length; i++) {
cArray[i] = bArray[bArray_index++];
}
}
return cArray;
}

/**
* 求两数之间比较小的一个数
*
* @param a
* @param b
* @return
*/
public static int getMin(int a, int b) {
return a - b <= 0 ? a : b;
}
}

㈣ Java编程:两个int类型有序数组A和B，长度分别为m和n，合并成有序数组C，并给出时间复杂度。

//两个有序的话，那么只用每次都从头部开始取值，然后插入到C数组里面
//所以时间复杂度为O(m+n)
publicvoidmergeArray(int[]a,int[]b,int[]c){
intm=0;
intn=0;
intx=0;
while(m<a.length&&n<b.length){
if(a[m]<=b[n]){
c[x++]=a[m++];
}else{
c[x++]=b[n++];
}
}
}

㈤ java中，两个已排序数组求并集的题，要求时间复杂度O(m+n)

public class Exam
{
public static void main(String[] args)
{
int[] a={1,5,5,20,88,88,88,125,500,1001};
int[] b={2,2,5,14,16,20,87,88,88,100,129,500};

for(int n : combination(a,b))
System.out.printf("%d ",n);
}
static int[] combination(int[] a,int[] b)
{
int lena=a.length,lenb=b.length;
int lenc=lena+lenb;
int[] c=new int[lenc];
int i=0,j=0,k=0;

while(i<lena&&j<lenb)
{
if(a[i]<b[j])
c[k++]=a[i++];
else
c[k++]=b[j++];
}
for(;i<lena;i++)
c[k++]=a[i];
for(;j<lenb;j++)
c[k++]=b[j];
// System.out.println("a.length="+i);
// System.out.println("b.length="+j);
// System.out.println("c.length="+k);
return c;
}
}

㈥ 用java把两个有序的数组合并为一个有序的数组，帮我把程序看下哪里出错了

首先是while (adex<=a.length&&bdex<=b.length) 这里adex超出a的大小了，bdex也是，不应该有=， 第二个问题是，a或b没全部放进c时，你的逻辑错了，应该下面这样做就没问题了，自己琢磨琢磨吧
private int[] hebing(int a[], int b[]) {
int c[] = new int[a.length + b.length];
int adex = 0,bdex = 0,cdex = 0;

while (adex<a.length&&bdex<b.length) {
if (a[adex]<=b[bdex]) {
c[cdex] = a[adex];
adex++;
}else {
c[cdex] = b[bdex];
bdex++;
}
cdex++;
}
if (bdex<b.length) { //a全部放进c了，而b没有放完
for (int i = bdex; i < b.length; i++) {
c[cdex] = b[bdex];
cdex++;
}
}else if (adex<a.length){ //b全部放进c了，而a没有放完
for (int i = adex; i < a.length; i++) {
c[cdex] = a[adex];
cdex++;
}
}
return c;
}

㈦ 用java将两个乱序数组合成一个有序数组代码怎么写

可供参考，代码如下：

importjava.util.ArrayList;
importcom.demo.test.MaoPao;

publicclassArrayListAdd{
	publicstaticvoidmain(String[]args){
		inta[]={1,6,9,4,5};
		intb[]={7,0,3,2,8};
		ArrayList<Integer>alist=newArrayList<Integer>(a.length+b.length);
		for(inti=0;i<a.length;i++){
			alist.add(a[i]);
		}
		for(intj=0;j<b.length;j++){
			alist.add(b[j]);
		}
		intc[]=newint[alist.size()];
		for(inti=0;i<alist.size();i++){
			c[i]=alist.get(i);
		}
		MaoPaomySort=newMaoPao();
		mySort.bubbleSort(c);
		System.out.println("整合后的数组是：");
		for(intk=0;k<c.length;k++){
			System.out.print(c[k]);
		}
	}

	publicvoidbubbleSort(int[]array){
		inttemp;
		for(inti=0;i<array.length;i++){//趟数
			for(intj=0;j<array.length-i-1;j++){//比较次数
				if(array[j]<array[j+1]){
					temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
			}
		}
	}
}

㈧ 找两个有序数组的中位数的几种方式

我用5个思路的来解决两个非减序数组的中位数.但是成功的只有四个,思路3边界问题太严重.
有时间再来弄好他,他在考试中也不适合使用(边界问题没法快速解决,网上也有人说小数据枚举法确定边界),总的来说费事.

主函数:

#include<stdio.h>
#include<time.h>
#include<limits.h>

doublefindMedianSortedArrays_1(int*nums1,intnums1Size,int*nums2,intnums2Size);
doublesss(inta[],intm,intb[],intn,intk);
doublefindMedianSortedArrays_2(int*nums1,intnums1Size,int*nums2,intnums2Size);
doublefindMedianSortedArrays_3(int*nums1,intnums1Size,int*nums2,intnums2Size);
doublefindMedianSortedArrays_4(int*nums1,intnums1Size,int*nums2,intnums2Size);
doublefindMedianSortedArrays_5(int*nums1,intnums1Size,int*nums2,intnums2Size);

intmain(){
	clock_tstart_t,end_t;
	doubletotal_t;
	doublemid=0;
//			1234567891011
	intstr1[1000]={0,2,4,5,7,9,10,15,21,23,25},
	str2[1000]={5,6,9,15,17,18,20,23,24,26,27,29,50};
//			12345678910111213
	start_t=clock();
	mid=findMedianSortedArrays_1(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法1:CPU占用的总时间：%fns
",(total_t*1000000000));
	printf("中位数%f
",mid);

	start_t=clock();
	mid=findMedianSortedArrays_2(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法2:CPU占用的总时间：%fns
",(total_t*1000000000));
	printf("中位数%f
",mid);

	start_t=clock();
	mid=findMedianSortedArrays_3(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法3:CPU占用的总时间：%fns
",(total_t*1000000000));
	printf("中位数%f
",mid);

	start_t=clock();
	mid=findMedianSortedArrays_4(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法4:CPU占用的总时间：%fns
",(total_t*1000000000));
	printf("中位数%f
",mid);

	start_t=clock();
	mid=findMedianSortedArrays_5(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法5:CPU占用的总时间：%fns
",(total_t*1000000000));
	printf("中位数%f
",mid);

	return0;
}

思路一:

/*
方法1:采用归并两个非减数组形成新非减数组,然后求取新数组的中位数.
性能分析:归并两数组的时间复杂度O(n+m),查找中位数时间复杂度O(1).所以时间复杂度O((n+m)*1)=O(m+n)
*/
doublefindMedianSortedArrays_1(int*nums1,intnums1Size,int*nums2,intnums2Size){
	inti=0,j=0,k=0;
	intc[10000]={0};
	doublemid_f=(nums1Size+nums2Size);
	intsign=(!((int)mid_f&0x1));
	if((!nums1Size)&&(!nums2Size))return-1;
	/*mid_f=(mid_f/2);
	if(nums1Size==0){
		return((nums2[(int)mid_f]+nums2[(int)(mid_f-sign)])/2);
	}
	if(nums2Size==0){
		return((nums1[(int)mid_f]+nums1[(int)(mid_f-sign)])/2);
	}*/
	while((i<nums1Size)&&(j<nums2Size))
	{
		c[k++]=(nums1[i]<=nums2[j])?nums1[i++]:nums2[j++];
	}
	while(i<nums1Size)
	{
		c[k++]=nums1[i++];
	}
	while(j<nums2Size)
	{
		c[k++]=nums2[j++];
	}
	//mid_f=(k&0x1)?(c[(k/2)]):(((c[(k/2+sign)])+(c[(k/2)]))/2);
	mid_f=(((c[(k/2-sign)])+(c[(k/2)]))/2);
	
	printf("OKk=%d(nums1Size+nums2Size)=%di=%dj=%d
",k,(nums1Size+nums2Size),i,j);
	i=0;
	while(i<=k)
	{
		printf("c[%d]=%d
",i,c[i]);
		i++;
	}
	
	returnmid_f;
}

思路二:

/*
用统计方法,从小到大对两数组同时进行归并式的遍历,并计数.当计数值等于两数组的中位数的下标,就找到中位数.
性能分析:时间复杂度是归并时间复杂度的一半,即O(m+n)=O((m+n)/2)
*/
doublefindMedianSortedArrays_5(int*nums1,intnums1Size,int*nums2,intnums2Size){
inti=0,j=0,k=0;
intmiddle=(nums1Size+nums2Size);
doublesign=(!(middle&0x1));
if((nums1Size==0)&&(nums2Size==0))return-1;
middle=(middle/2);
if(nums1Size==0){
return((nums2[(int)middle]+nums2[(int)(middle-sign)])/2);
}
if(nums2Size==0){
return((nums1[(int)middle]+nums1[(int)(middle-sign)])/2);
}
if(sign){
for(i=0,j=0,k=0;i<=(int)(middle-sign);i++)
{
(nums1[j]<=nums2[k])?(nums1[(j++)]):(nums2[k++]);
}
middle=(nums1[j]<=nums2[k])?(nums1[j--]):(nums2[k--]);//偶数中位数的前半部分最大值
middle=((middle+((nums1[j]<=nums2[k])?(nums1[j]):(nums2[k])))/2);//[偶数中位数的后半部分最小值+middle(偶数中位数的前半部分最大值)]/2=middle
}
else
{
for(i=0,j=0,k=0;i<=(middle-sign);i++)
{
(nums1[j]<=nums2[k])?(nums1[(j++)]):(nums2[k++]);
}
middle=(nums1[j]<=nums2[k])?(nums1[j]):(nums2[k]);
}
returnmiddle;
}

测试结果:(出现的特例:这着实具有不可避免性.输入全体样本中重复率高时,结束条件能被错误触发.)

/*

OK k = 24 (nums1Size + nums2Size) = 24 i = 11 j = 13

c[0] = 0

c[1] = 2

c[2] = 4

c[3] = 5

c[4] = 5

c[5] = 6

c[6] = 7

c[7] = 9

c[8] = 9

c[9] = 10

c[10] = 15

c[11] = 15

c[12] = 17

c[13] = 18

c[14] = 20

c[15] = 21

c[16] = 23

c[17] = 23

c[18] = 24

c[19] = 25

c[20] = 26

c[21] = 27

c[22] = 29

c[23] = 50

c[24] = 0

方法1:CPU 占用的总时间：4000000.000000 ns

中位数 16.000000

方法2:CPU 占用的总时间：0.000000 ns

中位数 16.000000

nums1Size = 11 nums1[5] = 9 nums2Size = 13 nums2[6] = 20

nums1Size = 6 nums1[3] = 21 nums2Size = 7 nums2[3] = 15

nums1Size = 4 nums1[2] = 15 nums2Size = 4 nums2[2] = 18

nums1Size = 2 nums1[0] = 15 nums2Size = 3 nums2[1] = 17

nums1Size = 2 nums1[0] = 15 nums2Size = 2 nums2[0] = 15

方法3:CPU 占用的总时间：15000000.000000 ns

中位数 15.000000

la = 9 ra = 9 lb = 20 rb = 20

la = 21 ra = 21 lb = 15 rb = 15

la = 10 ra = 15 lb = 17 rb = 18

la = 15 ra = 15 lb = 17 rb = 17

la = 15 ra = 21 lb = 15 rb = 17

方法4:CPU 占用的总时间：10000000.000000 ns

中位数 16.000000

方法5:CPU 占用的总时间：0.000000 ns

中位数 16.000000

*/

㈨ 如何将两个有序数组合并为一个有序数组，用函数做，一个循环搞定

这很简单：
代码如下（此处不考虑Object，假设为int[ ]）：
public int[ ] getNewArrays(int[ ] one, int [] two){
int len=one.length;
int len2=two.length;
int len3=oneLength+twoLength; //得到两数组长度和;
int[] newArray=new int [len3]; //创建第三个数组，长度=两数组长度之和;
for(int i=0;i<len3;i++){
if(i<len){ //如果i<len,则赋值为one中的元素;
newArray[i]=one[i];
continue;
}
int t=i-len; // t 从0开始
newArray[i]=two[t]; //后面的元素 赋值为two中的元素;

} //对第三个数组一一赋值，值为前两个数组;
Arrays.sort(newArray); //对第三个数组排序;此处使用的是java自带的sort方法;
//也可使用冒泡排序,此处不演示;
return newArray;
}
完