我的代码
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}
答案 0 :(得分：9)
这就是你要找的东西：
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]
答案 1 :(得分：8)
答案 2 :(得分：4)
当您想要唯一性时，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);
}
}
显然，这里有从数组到列表转换的开销，然后是要设置的列表，然后再设置回数组。但是，通常不值得使代码复杂的代码更快地执行某些操作 - 只有当您发现代码的这一部分存在性能瓶颈时，才能使用直接且更长（代码方式）的解决方案。 / p>
使用Set还可以避免常见错误，即迭代数组以搜索元素以确认要添加的元素不重复。通常，诸如此类的解决方案具有O（n ^ 2）时间复杂度（参见this）。
当你的数组有10个元素时，这不会成为一个问题，但是如果你有两个数组，比如每个1000个独特的元素，你将会做很多不必要的步行，使你的代码变得非常慢。在这种情况下，在基于数组的解决方案中，通过遍历数组进行重复检查，您必须执行1000 * 1000/2 = 500K操作，而基于集合的操作将接近5k：
基于集合的解决方案是O（n）。如果你假设这些操作大致相同（不是真的，但不是很差的近似值），这快100倍。
此外，随着独特元素数量的增加，这种情况迅速增加 - 对于每个阵列中的10K元素，基于阵列的步行解决方案将需要50,000,000个操作，而基于集合的操作将需要15,000个订单
希望这有帮助。
答案 3 :(得分：1)
你发布的代码是处理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;
}
答案 4 :(得分：1)
A = {1,1,1,4} B = {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 ;
}
}
答案 5 :(得分：0)
//我希望这个例子很简单。 //传递两个数组，你肯定会获得没有重复项的数组的UNION。
public class 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;
}}
答案 6 :(得分：0)
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;
}
答案 7 :(得分：0)
Set<String> set = new HashSet<>(list1);
set.addAll(list2);
List<String> union = new ArrayList<>(set);
答案 8 :(得分：0)
我希望本示例将简单地一个。传递两个数组，并且您肯定会获得没有重复项的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;
}
答案 9 :(得分：0)
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();
}