導航:首頁 > 編程語言 > java兩個有序數組

java兩個有序數組

發布時間:2023-01-25 03:17:34

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;
}

閱讀全文

與java兩個有序數組相關的資料

熱點內容
如何啟動後端伺服器 瀏覽:36
電腦安卓軟體界面怎麼默認恢復 瀏覽:266
java程序員接項目 瀏覽:600
炒股指標源碼官網 瀏覽:633
為什麼java安裝不了 瀏覽:559
魅族怎麼更新手機安卓系統 瀏覽:99
網路鄰居命令 瀏覽:870
哈啰出行app如何開鎖 瀏覽:948
美團眾包新手怎麼操作app 瀏覽:446
加密簡訊在哪打開 瀏覽:737
即刻app怎麼搜情侶頭 瀏覽:341
順豐app寄件優惠券怎麼用 瀏覽:280
照片安卓手機如何傳到蘋果手機上 瀏覽:670
Java如何Linux伺服器 瀏覽:501
如何訪問伺服器上的一堆圖片 瀏覽:756
蘋果app怎麼改成外服 瀏覽:469
android獲取區域網ip 瀏覽:4
最新的單片機開發軟體 瀏覽:406
我的世界ec伺服器怎麼調中國版 瀏覽:698
layuissh源碼 瀏覽:27