我的代码
class Union {
//Search Function
static boolean search(int A[], int i) {
for (int k = 0; k < A.length; k++) {
if (A[k] == i) {
return true;
}
}
return false;
}
//union
static void union(int A[][], int B[][]) {
int i = 0;
int count = 0;
int C[] = new int[A.length + B.length];
for (; i < A.length; i++) {
if (!(search(B, A[i]))) {
C[count] = A[i];
count++;
}
}
for (; i < (A.length + B.length); i++) {
C[count] = B[i - A.length];
count++;
}
System.out.println("This is Union Of 2 D Array ");
System.out.println();
for (int k = 0; k < count; k++) {
System.out.println(C[k]);
}
System.out.println();
}
public static void main(String... s) {
union(new int[]{1, 1, 1, 4,}, new int[]{1, 4, 4, 4, 1, 2});
}
}
我使用这个输出来查找2d数组的并集，但我得到的输出是错误的。我不想在Java中使用任何预定义的接口和方法。我的答案应该是{1, 2, 4}
A= {1,2,3,3}
B={2,3,1,1}
c={1,2,3}
这就是你要找的:
import java.util.Arrays;
public class Union
{
public static void main(String[] args)
{
int[] A = {1, 2, 3, 3};
int[] B = {2, 3, 1, 1};
System.out.println(Arrays.toString(unionArrays(A, B)));
}
/* Union of multiple arrays */
public static int[] unionArrays(int[]... arrays)
{
int maxSize = 0;
int counter = 0;
for(int[] array : arrays) maxSize += array.length;
int[] accumulator = new int[maxSize];
for(int[] array : arrays)
for(int i : array)
if(!isDuplicated(accumulator, counter, i))
accumulator[counter++] = i;
int[] result = new int[counter];
for(int i = 0; i < counter; i++) result[i] = accumulator[i];
return result;
}
public static boolean isDuplicated(int[] array, int counter, int value)
{
for(int i = 0; i < counter; i++) if(array[i] == value) return true;
return false;
}
}
[1, 2, 3]
不是专门回答您的问题，但是如果您实际上只是想获得一个联合，您可能应该使用java Set接口。
当您需要惟一性时，选择Set是很自然的。为了避免大量的转换，您可以将int[]更改为Integer[]，从而获得一个非常简洁的并集方法。
下面是一个完整的工作示例:
import java.util.*;
public class Union {
// Search Function
public boolean search(Integer a[], Integer i) {
for(int k = 0; k < a.length; k++) {
if(a[k] == i) {
return true;
}
}
return false;
}
// Union
public void union(Integer[] a, Integer[] b) {
Set<Integer> set = new HashSet<Integer>(Arrays.asList(a));
set.addAll(Arrays.asList(b));
Integer[] unionArray = set.toArray(new Integer[set.size()]);
System.out.println(Arrays.toString(unionArray));
}
public static void main(String...s) {
Integer[] array1 = new Integer[]{1,1,1,4,};
Integer[] array2 = new Integer[]{1,4,4,4,1,2};
new Union().union(array1, array2);
}
}
显然，这里有从数组转换到列表，然后从列表转换到set，然后从set转换回数组的开销。然而，用复杂的代码来做一些更快的事情通常是不值得的——只有当你发现这部分代码有性能瓶颈时，才有必要采用直接的、更长的(代码方面的)解决方案。
使用Set还可以避免一个常见的错误，即遍历数组来搜索元素，以确认要添加的元素不是重复的。通常，这样的解决方案具有O(n^2)的时间复杂度(参见此)。
当你的数组有10个元素时，这不是一个问题，但是如果你有两个数组，比如说，每个数组有1000个唯一的元素，你将做很多不必要的遍历，使你的代码非常慢。在这种情况下，在通过遍历数组进行重复检查的基于数组的解决方案中，您必须执行1000 * 1000/2 = 500K操作，而基于集合的操作将接近5k:
- 1000将第一个数组转换为列表，
- 1000将列表转换为集合，
- 1000将第二个数组转换为列表，
- 1000将第二个数组添加到集合和
- 1000将其从set a array转换回来)
作为基于集合的解为O(n)。如果您假设这些操作大致相同(不正确，但这不是一个糟糕的近似)，则速度将提高100倍。
此外，这随着唯一元素数量的增加而快速增长——对于每个数组中10K个元素，基于数组的遍历解决方案将需要50,000,000次操作，而基于集合的遍历解决方案将需要15,000次操作。
您发布的代码是处理1d数组，而不是2d =)代码似乎试图将两个数组的内容连接到另一个数组。为此，只需执行以下操作:
public static int[] joinArrays(int[] a, int[] b) {
if (a == null || b == null)
throw new IllegalArgumentException("Both arrays must be non-null");
int c[] = new int[a.length + b.length];
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);
return c;
}
A = B{1 1 1、4}={1、4、4、4、1、2}
集合A和B的数学并集是C = {1,4,2}
或者您想要重复，如，C = {1,1,1,1,1,2,4,4,4,4}
哪一个是你期望的输出?第一个还是第二个?
public class Union_2{
static int size;
public static void main(String [] args){
int [] a = {1,1,1,4};
int [] b = {1,4,4,4,1,2};
int [] c = Union_finder(a,b);
for(int i = 0 ; i< size ; i++){
System.out.print(c[i]+" ");
}
}
public static int[] Union_finder(int [] a,int [] b){
int [] c = new int[a.length+b.length];
int i=0,j=0,k=0;
for(;i<a.length;i++){
boolean bool = check(a[i],c);
if( bool == false){
c[k] = a[i];
size++;
k++;
}
}
for(;j<b.length;j++){
boolean bool = check(b[j],c);
if( bool== false){
c[k] = b[j];
size++;
k++;
}
}
return c ;
}
public static boolean check(int x,int [] c){
if(size == 0){
return false;
}
else{
for(int i = size - 1 ; i >= 0 ; i--){
if( c[i] == x){
return true ;
}
}
}
return false ;
}
}
//我希望这个例子能简单一点。//传递两个数组，你肯定会得到没有重复项的数组的UNION。
<>之前公共类UnionOfArrays{
public int[] getUnion(int[] arr1, int[] arr2)
{
int[] array = MergeSort.mergeArray(arr1, arr2);
int[] arrReturn = getunique(array);
return arrReturn;
}
public int[] getunique(int[] array)
{
int[] arrTemp = new int[array.length];
int[] arrReturn;
int index = 0;
for (int i = 0; i < array.length; i++)
{
Boolean found = false;
for (int j = 0; j < i; j++)
{
if (array[i] == array[j])
{
found = true;
break;
}
}
if (!found)
{
arrTemp[index++] = array[i];
}
}
arrReturn = new int[index];
for (int i = 0; i < index; i++)
{
arrReturn[i] = arrTemp[i];
}
return arrReturn;
}}
public static int[] arrayUnion(int a1[], int a2[]){
int[] resultArray={};
ArrayList<Integer> arrayList = new ArrayList<Integer>();
if(a1.length>a2.length){
resultArray=new int[a1.length];
}else resultArray=new int[a2.length];
for(int element : a1){
arrayList.add(Integer.valueOf(element));
}
for(int element:a2){
if(! arrayList.contains(element)){
arrayList.add(Integer.valueOf(element));
}
}
resultArray = arrayList.stream().mapToInt(i->i).toArray(); // only in java 8
return resultArray;
}
Set<String> set = new HashSet<>(list1);
set.addAll(list2);
List<String> union = new ArrayList<>(set);
我希望这个例子能简单一点。传递两个数组，你肯定会得到没有重复项的数组的UNION。
private static int[] FindUnionOfTwoArray(int[] array1, int[] array2) {
Map<Integer,Integer> map=new HashMap<>();
for (int element : array1) {
map.put(element, element);
}
for (int element : array2) {
map.put(element, element);
}
int[] newArray=new int[map.size()];
int con=0;
for(Map.Entry<Integer, Integer> lst:map.entrySet()) {
newArray[con]=lst.getValue();
con++;
}
return newArray;
}
public static int doUnion(int a[], int n, int b[], int m)
{
HashSet<Integer> hs = new HashSet<Integer>();
for (int i = 0; i < n; i++)
hs.add(a[i]);
for (int i = 0; i < m; i++)
hs.add(b[i]);
return hs.size();
}