java求两个数组的并集,并返回新的数组.
求两个数组的并集,并返回一个新的数组,数组的长度是两个数组的和,并且如果并集中出现重复的数,则会用0填满数组,不能是要任何的hashset以及linklist这种方法,就是最后返回一个新的数组,这个数组包含了这两个数组的并集.条件如下(不使用hashset,linklist)
可以先让数组充满0，在前面填充数字，最后的0可以看做是重复数字填满的
public static int[] union(int [] a, int [] b) {
Arrays.sort(a);
Arrays.sort(b);
int lena = a.length, lenb = b.length;
int [] ans = new int[lena +lenb];
Arrays.fill(ans, 0);
int i = 0, j = 0, k = 0;
while (i < lena && j < lenb) {
int t = a[i] < b[j] ? a[i++] : b[j++];
if (k == 0 || ans[k - 1] != t) {
ans[k++] = t;
}
}
while (i < lena) {
if (ans[k - 1] != a[i]) {
ans[k++] = a[i];
}
i++;
}
while (j < lenb) {
if (ans[k - 1] != b[j]) {
ans[k++] = b[j];
}
j++;
}
return ans;
}
目前返回的结果长度为13,但是会有重复的结果,我想把这些重复的结果去除,并且用0补充完数组的长度,应该用什么方法.
你如果排序好了的话 就使用循环该数组 递归判断下一位是否相等 若相等则为0并接着递归 若不相等则返回
求并集：
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class UnionTwoArraysNumbers {
public static void main(String[] args) {
Integer[] array1 = { 10,5,7,8,5,9,4 };
System.out.println( "Array 1 : " + Arrays.toString(array1));
Integer[] array2 = {7,5,15,7,7,9,10 };
System.out.println( "Array 2 : " + Arrays.toString(array2));
Set<Integer> unionOfArrays = new HashSet<>();
unionOfArrays.addAll(Arrays.asList(array1));
unionOfArrays.addAll(Arrays.asList(array2));
Integer[] unionArray = {};
unionArray = unionOfArrays.toArray(unionArray);
System.out.println( "Union of two arrays: " + Arrays.toString(unionArray));
}
}
如有帮助，还请采纳！谢谢！
循环遍历两个数组就行了啊，每次循环的时候判断是否存在了，如果存在了 当前元素设置为0
public static void main(String[] args) {
int a1[]={10,5,7,5,9,4};
int a2[] = {7,5,15,7,7,9,10};
int result1[] = new int[a1.length+a2.length];
int index= 0;
for (int a :a1){
if(!arrayHasInt(result1,a)){
result1[index]=a;
index++;
}
}
for (int a :a2){
if(!arrayHasInt(result1,a)){
result1[index]=a;
index++;
}
}
System.out.println("result1:"+Arrays.toString(result1));
}
private static boolean arrayHasInt(int[] result1, int a) {
for (int a_:result1){
if(a_ == a && a !=0){//这里加个判断就可以过滤数组本来有0的情况
return true;
}
}
return false;
}
import java.util.Arrays;
public class Test {
public static int[] union(int[] a1, int[] a2) {
// 按题干要求1，创建一个新数组长度是原数组之合，默认初始化都为0，所以自然0填充了
final int[] result = new int[a1.length + a2.length];
// 按题干要求2，排序两个数组
Arrays.sort(a1);
Arrays.sort(a2);
int resultPosition = 0;
int a1Position = 0;
int a2Position = 0;
// 类似于归并排序法，题干2循环两个数组，同时记录每个数组的使用的索引
for (; a1Position < a1.length; a1Position++) {
for (; a2Position < a2.length; a2Position++) {
// 用较小的数填充结果数组
if (a1[a1Position] < a2[a2Position]) {
// 存在相同数据的直接忽略
if (resultPosition == 0 || result[resultPosition - 1] != a1[a1Position]) {
result[resultPosition++] = a1[a1Position];
}
break;
} else if (a1[a1Position] > a2[a2Position]) {
// 存在相同数据的直接忽略
if (resultPosition == 0 || result[resultPosition - 1] != a2[a1Position]) {
result[resultPosition++] = a2[a2Position];
}
}
}
}
// 将数组1中可能未处理的数据直接追加
for (; a1Position < a1.length; a1Position++) {
// 忽略数组1可能存在测重复元素
if (a1[a1Position] != result[resultPosition - 1]) {
result[resultPosition++] = a1[a1Position];
}
}
// 将数组2中可能未处理的数据直接追
for (; a2Position < a2.length; a2Position++) {
// 忽略数组2可能存在测重复元素
if (a2[a2Position] != result[resultPosition - 1]) {
result[resultPosition++] = a2[a2Position];
}
}
return result;
}
public static void main(String[] args) {
int[] a1 = {10, 5, 7, 5, 9, 4};
int[] a2 = {7, 5, 15, 7, 7, 9, 10};
int[] result1 = union(a1, a2);
System.out.println("result1" + Arrays.toString(result1));
int[] a3 = {0, 2, -4, 6, 10, 8};
int[] a4 = {12, 0, -4, 8};
int[] result2 = union(a3, a4);
System.out.println("result2" + Arrays.toString(result2));
}
}
最终打印结果：
public class test6 {
public static void main(String[] args) {
int[] array1 = { 10,5,7,5,9,4 };
int[] array2 = {7,5,15,7,7,9,10 };
System.out.println(Arrays.toString(union(array1,array2)));
}
//
public static int[] union(int arr1[],int arr2[]){
int tols=0;
int[] arr3 = new int[arr1.length + arr2.length];
//数组合并
for (int i = 0; i < arr3.length; i++) {
if(i<arr1.length){
arr3[i]=arr1[i]; }
else {
arr3[i]=arr2[i-arr2.length+1];
}
}
//数组排序
for(int i = 0 ;i< arr3.length -1; i++) {
int temp = 0;
for (int j = 0; j < arr3.length - 1 - i; j++) {
if (arr3[j] > arr3[j + 1]) {
temp = arr3[j];
arr3[j] = arr3[j + 1];
arr3[j + 1] = temp;
}
}
}
return distinct(arr3);
}
//重复值补充0
public static int [] distinct (int [] arr){
int []distinct=new int[arr.length];
int tops=0;
for (int i = 0; i < arr.length-1; i++) {
if(arr[i]!=arr[i+1]){
distinct[i-tops]=arr[i];
distinct[i-tops+1]=arr[i+1];
}else {
tops ++;
}
}
return distinct;
}
}
import java.util.Arrays;
import java.util.HashSet;
public class Main
{
public static void main(String[] args)
{
Integer[] firstArray = {0,2,4,6,8};
Integer[] secondArray = {1,3,5,7,9};
HashSet<Integer> set = new HashSet<>();
set.addAll(Arrays.asList(firstArray));
set.addAll(Arrays.asList(secondArray));
System.out.println(set);
//convert to array
Integer[] union = {};
union = set.toArray(union);
System.out.println(Arrays.toString(union));
}
}