una - Cómo hacer unión, intersección, diferencia e invertir datos en Java

invertir un arreglo recursivamente java

Question

Quiero tener operaciones de unión, intersección, diferencia e inversión en Java.

Primero tengo 2 instancias de ArrayList<Integer>

a = [0,2,4,5,6,8,10]
b = [5,6,7,8,9,10]

una unión b debería devolver c = [0,2,3,4,5,6,7,8,9,10]

una intersección b debería devolver c = [5,8,10]

una deferencia b debería devolver c = [0,2,3,4]

revertir a = [10,8,6,5,4,2,0]

Algo como esto.

¿Cómo implementar ese método en Java?

Actualización : tengo que comenzar con esta plantilla:

package IntSet;
import java.util.ArrayList;
import java.util.Collection;


public class IntSet {

private ArrayList<Integer> intset;

public IntSet(){
    intset = new ArrayList<Integer>();
}

public void insert(int x){
    intset.add(x);
}

public void remove(int x){
    //implement here
    intset.indexOf(x);
}

public boolean member(int x){
    //implement here
    return true;
}

public IntSet intersect(IntSet a){
    //implement here
    return a;
}

public IntSet union(IntSet a){
    //implement here
    return a;
}

public IntSet difference(IntSet a){
    //implement here
    IntSet b = new IntSet();
    return b; 
}

Answer 1

Este fragmento encontrará la unión de dos colecciones usando el método apache commons CollectionUtils.union

Collection<String> totalFriends = CollectionUtils.union(yourFriends, myFriends);

Answer 2

Muchas de las respuestas le dicen que use bibliotecas que harán el trabajo por usted. Si bien esta es la solución correcta para el mundo real, tenga en cuenta que está haciendo la tarea, y su maestro probablemente quiera que comprenda cómo se escriben las funciones, no solo cómo encontrar las bibliotecas para que hagan el trabajo por usted.

Dicho esto, tienes un buen comienzo con el código que has mostrado. Tomemos el problema paso a paso.

Primero, ¿sabe dónde se encuentra la documentación de Java? http://download.oracle.com/javase/1.4.2/docs/api/ esto es crítico, ya que así es como descubres qué funciones hacen qué. Aquí está el enlace a Java 1.4. No noté qué versión estás usando, pero Java es compatible con versiones anteriores, así que esto debería ser suficiente.

En los documentos, busque la entrada ArrayList.

Ahora que tenemos los documentos API, necesitamos desglosar su pregunta. has publicado el código, así que lo abordaré función por función.

insert (): ¿tiene que tener una lista ordenada, o no importa? ¿O tiene la garantía de que se le proporcionarán los valores en orden? ¿Ya aprendiste los algoritmos de clasificación?

remove (): esta función no funciona. Eche un vistazo a la API ArrayList y vea cómo eliminar un elemento de la lista. Usa ese método.

member (): su método miembro no funciona. Debe verificar cada entrada de la lista y determinar si el miembro actual coincide con el argumento de la función. ¿Has aprendido sobre bucles?

intersect (): ok, dime en inglés qué se supone que debe hacer intersect. No use la descripción del maestro si puede ayudarlo; use sus propias palabras (tenga en cuenta que este es un ejercicio para que el OP pueda aprender a programar, así que no se lo conteste).

difference (): de nuevo, dime en inglés qué se supone que debe hacer.

reverse (): de nuevo, dame la descripción en inglés de lo que se supone que debe hacer.

Una vez que tenga descripciones en inglés, describa un algoritmo que pueda hacer el trabajo. no lo escriba en Java todavía. simplemente escriba un algoritmo, en inglés, que describa cómo haría el trabajo de forma manual, con lápiz y papel.

en este punto, intente convertir el algoritmo a código Java.

Answer 3

Primero, las operaciones que describes (excepto en reversa) son operaciones establecidas, no operaciones de lista, así que usa HashSet o (si necesitas hacer un pedido) TreeSet.

    Set<Integer> a = new TreeSet<Integer>(Arrays.asList(new Integer[]{0,2,4,5,6,8,10}));
    Set<Integer> b = new TreeSet<Integer>(Arrays.asList(new Integer[]{5,6,7,8,9,10}));

    //union
    Set<Integer> c = new TreeSet<Integer>(a);
    c.addAll(b);
    System.out.println(c);

    //intersection
    Set<Integer> d = new TreeSet<Integer>(a);
    d.retainAll(b);
    System.out.println(d);

    //difference
    Set<Integer> e = new TreeSet<Integer>(a);
    e.removeAll(b);
    System.out.println(e);

    //reverse
    List<Integer> list = new ArrayList<Integer>(a);
    java.util.Collections.reverse(list);
    System.out.println(list);

Answer 4

Si está utilizando Sets (como debería, para todos los que no son inversos son operaciones de Set), Guava proporciona estas operaciones en su clase Sets .

Set<Integer> union = Sets.union(set1, set2);
Set<Integer> intersection = Sets.intersection(set1, set2);
Set<Integer> difference = Sets.difference(set1, set2);

Todos estos devuelven vistas no modificables, respaldadas por los Conjuntos originales.

Ver Explicación de Guava -> Utilidades de la Colección -> Conjuntos

Si las listas son lo que tiene, puede convertirlas a un conjunto utilizando el constructor de copias presente en todas las colecciones estándar:

List<X> list = new ArrayList<>();
// fill up list here
Set<X> set = new HashSet<>(list);

Answer 5

Solo lo dejo aquí. Hay una nueva forma con java-8 y streams

List<Integer> listA = Arrays.asList(0, 2, 4, 5, 6, 8, 10);
List<Integer> listB = Arrays.asList(5, 6, 7, 8, 9, 10);

List<Integer> intersection = listA.stream()
        .filter(listB::contains)
        .collect(Collectors.toList());

List<Integer> union = Stream.concat(listA.stream(), listB.stream())
        .distinct().sorted()
        .collect(Collectors.toList());

List<Integer> aDiffB = listA.stream()
        .filter(i -> !listB.contains(i))
        .collect(Collectors.toList());

System.out.println(intersection); // [5, 6, 8, 10]
System.out.println(union); // [0, 2, 4, 5, 6, 7, 8, 9, 10]
System.out.println(aDiffB); // [0, 2, 4]

Answer 6

//Union 
List<Integer> c = new ArrayList<Integer>(a.size() + b.size());
addNoDups(c,a);
addNoDups(c,b);

private void addNoDups(List<Integer> toAddTo,List<Integer> iterateOver) {
    for(Integer num:iterateOver){
        if(toAddTo.indexOf(num) == -1) {
            toAddTo.add(num);
        }
    }
}

//intersection
List<Integer> c = new ArrayList<Integer> (a.size() > b.size() ?a.size():b.size());
c.addAll(a);
c.retainAll(b);

//difference a-b
List<Integer> c = new ArrayList<Integer> (a.size());
c.addAll(a);
c.removeAll(b);