Объединение двух массивов в java?

ProgramBox

Объединение двух массивов в java?

Post author:admin
Запись опубликована:9 мая, 2023
Post category:Вопросы по программированию

#java #arrays #multidimensional-array

#java #массивы #многомерный массив

Вопрос:

Мой код

 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 массива. но вывод, который я получаю, неверен. я не хочу использовать 2 каких-либо предопределенных интерфейса и метода в java.
мой ответ должен быть
{1,2,4}

Пример

 A= {1,2,3,3}
B={2,3,1,1}
c={1,2,3}

1. Похоже, что в вашем коде есть только одномерные массивы. Где находятся 2d-массивы?

2. если я ошибаюсь в этом коде, поправьте меня

3. @Guarav_Java: Трудно вас поправить, когда мы не знаем, что вы ищете, но Питер прав, вы используете только одномерные массивы. Обратите внимание, что идиоматическое объявление переменной типа массива заключается в том, чтобы сохранить всю информацию о типе вместе: int[] x вместо int x[] . Кроме того, имена параметров обычно имеют формат camelCase.

4. 2D массиву нужны два измерения, т.е. union(int[][] a, int[][] b) Что и делает его 2D (двумерным) массивом.

5. @Gaurav_Java Не могли бы вы привести пример? Пример ввода и ожидаемый результат.

Ответ №1:

Это то, что вы ищете:

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

    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]

Ответ №2:

Не отвечаю конкретно на ваш вопрос, но если вы на самом деле просто хотите получить объединение, вам, вероятно, следует использовать интерфейс Java Set. Подробности смотрите здесь.

Ответ №3:

Набор — естественный выбор, когда вы хотите уникальности. Чтобы избежать большого количества преобразований, вы можете изменить с 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 обратно в array. Однако обычно не стоит иметь запутанный код, который делает что-то быстрее — только когда вы обнаружите, что у вас есть узкое место в производительности в этой части кода, было бы полезно перейти к прямому и более длительному (с точки зрения кода) решению.

Использование Set также позволяет избежать распространенной ошибки, когда вы перебираете массив для поиска элемента, чтобы подтвердить, что добавляемый элемент не является дубликатом. Обычно такие решения, как это, имеют временную сложность O (n ^ 2) (см. Это).

Это не будет проблемой, когда ваши массивы содержат 10 элементов, но если у вас есть два массива, скажем, по 1000 уникальных элементов в каждом, вы будете выполнять много ненужных переходов, делая ваш код действительно медленным. В этом случае в решении на основе массива с проверкой дубликатов путем обхода массива вам пришлось бы выполнить 1000 * 1000 / 2 = 500 Тыс. операций, в то время как операция, основанная на множестве, будет близка к 5 тыс.:

1000 для преобразования первого массива в список,
1000 для преобразования списка в набор,
1000 для преобразования второго массива в список,
1000, чтобы добавить второй массив в набор и
1000, чтобы преобразовать его обратно из заданного массива)

в качестве решения на основе множеств используется O (n). Если вы предполагаете, что эти операции примерно одинаковы (неверно, но, тем не менее, неплохое приближение), это в 100 раз быстрее.

Более того, это быстро увеличивается с увеличением количества уникальных элементов — для 10 Тыс. элементов в каждом из массивов решение для обхода на основе массива потребовало бы порядка 50 000 000 операций, в то время как решение на основе набора заняло бы порядка 15 000.

Надеюсь, это поможет.

Ответ №4:

Опубликованный вами код имеет дело с одномерными массивами, а не с 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;
}

Ответ №5:

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

1. Первый вывод этого сообщения u в ответе также может быть выполнен в комментарии

2. Я добавил код, который вы искали, он находит объединение двух наборов и отображает результат, надеюсь, это поможет.

Ответ №6:

// Я надеюсь, что этот пример будет простым. // передайте два массива, и вы обязательно получите ОБЪЕДИНЕНИЕ массива без повторяющихся элементов.

открытый класс 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;
}}

Ответ №7:

  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;

    }

Ответ №8:

     Set<String> set = new HashSet<>(list1);
    set.addAll(list2);
    List<String> union = new ArrayList<>(set);

Ответ №9:

Я надеюсь, что этот пример будет простым. передайте два массива, и вы обязательно получите ОБЪЕДИНЕНИЕ массива без повторяющихся элементов.

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

Ответ №10:

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