Удалите повторяющиеся элементы из LinkedList, где вложенные элементы коллекции могут быть в любом порядке

У меня есть Nested LinkedList, который содержит некоторые элементы. Я хочу удалить дублирующийся внутренний LinkedList из Outter LinkedList. Порядок элемента не имеет значения. [Кошка, мышь, собака] такая же, как [Мышь, кошка, собака] и я Хотите удалить 1 из них. Пример:

Предположим,

[[Cat,Mouse,Dog],[Dog,Mouse,Cat],[Dog,Horse,Cat],[Dog,Tiger,Lion]]

тогда я хочу, чтобы вывести этот файл

[[Cat,Mouse,Dog],[Dog,Horse,Cat],[Dog,Tiger,Lion]]

Я попробовал. но я хочу Оптимальное решение...... Мой код ниже

for (int iBoardListCnt = 0; this.roomCombinationsMasterList != null && iBoardListCnt < this.roomCombinationsMasterList.size(); iBoardListCnt++) {

        LinkedList<Board> alRoomCombinationList = new LinkedList<>();
        alRoomCombinationList = this.roomCombinationsMasterList.get(iBoardListCnt);
        ArrayList<String> alTemp = new ArrayList();
        for (int icount = 0; icount < alRoomCombinationList.size(); icount++) {
            alTemp.add((alRoomCombinationList.get(icount).getRoomDescription() + alRoomCombinationList.get(icount).getDescription()).toString());
        }
        roomCombinationsMasterList.remove(iBoardListCnt);



        Collections.sort(alTemp, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareToIgnoreCase(s2);
            }
        });

        Iterator<LinkedList<Board>> iterator = roomCombinationsMasterList.iterator();
        while (iterator.hasNext()) {

            ArrayList<String> alTemp1 = new ArrayList<>();
            for (Board data : iterator.next()) {
                alTemp1.add((data.getRoomDescription() + data.getDescription()).toString());

            }
            Collections.sort(alTemp1, new Comparator<String>() {
                @Override
                public int compare(String s1, String s2) {
                    return s1.compareToIgnoreCase(s2);
                }
            });

            if (alTemp.equals(alTemp1)) {
                iterator.remove();
                continue;
            }

        }

        roomCombinationsMasterList.add(iBoardListCnt, alRoomCombinationList);

    }

В этом коде я взял элемент Fist из Nested LinkedList. сохраненный во временном LinkedList, я удалил этот элемент из основного arraylist.Now у меня есть следующий элемент из LinkedList, который хранится во 2-й временной LinkedList. Сортируйте LinkedList с помощью Comparator И используя метод equals(), сравните эти два LinkedList.If оба они одинаковы, а затем удалите 1 из них с помощью Iterator. пожалуйста, дайте мне Оптимальное решение по нему.

Ответ 1

Существует несколько способов удалить повторяющиеся элементы из вашего списка. Для "оптимального" решения, которое вам требуется, потребуется использовать соответствующую структуру данных, которая оптимизирована для работы contains. В вашем случае это будет HashSet.

Идея состоит в том, что, одновременно перемещая исходную коллекцию, вы поддерживаете набор пройденных элементов и проверяете, прошел ли текущий элемент. Этот подход изменяет исходную коллекцию на месте.

    List<List<String>> input = new LinkedList<List<String>>(Arrays.asList(
            Arrays.asList("Cat", "Mouse", "Dog"),
            Arrays.asList("Dog", "Mouse", "Cat"),
            Arrays.asList("Dog", "Horse", "Cat"),
            Arrays.asList("Dog", "Tiger", "Lion")));

    Set<Set<String>> distinctElements = new HashSet<Set<String>>();

    for (Iterator<List<String>> iterator = input.iterator(); iterator.hasNext(); ) {
        List<String> element = iterator.next();
        HashSet<String> elementAsSet = new HashSet<String>(element);
        if (!distinctElements.contains(elementAsSet)) {
            distinctElements.add(elementAsSet);
        } else {
            iterator.remove();
        }
    }

    System.out.println(input);

Второй вариант преобразует исходный список списков в LinkedHashSet<LinkedHashSet<String>>. LinkedHashSet ведет себя как a Set и List в одно и то же время (фактически, он имеет обе эти структуры данных под капотом). Таким образом, он устраняет дубликаты при сохранении порядка элементов, как вам нужно. Вероятно, это не вариант для вас, поскольку вы сказали, что вам нужно сохранить свой тип коллекции, но все же это хороший (и короткий) вариант, который стоит рассмотреть.

    LinkedHashSet<LinkedHashSet<String>> results = new LinkedHashSet<LinkedHashSet<String>>();
    for (List<String> strings : input) {
        results.add(new LinkedHashSet<>(strings));
    }
    System.out.println(results);

И, наконец, однострочный для Java 8:

LinkedList<LinkedList<String>> results = input.stream().map(LinkedHashSet::new).distinct()
        .map(LinkedList::new).collect(Collectors.toCollection(() -> new LinkedList<LinkedList<String>>()));

Или это более короткая версия, если вам не нужен тип возвращаемой коллекции:

List<List<String>> results = input.stream().map(LinkedHashSet::new).distinct()
        .map(LinkedList::new).collect(Collectors.toList());

Ответ 2

import java.util.*;

import static me.test.Test.Animal.*;
public class Test {

    public static enum Animal {
        Dog,Tiger,Lion,Horse,Cat,Mouse
    }

    public static void main ( String[] args ) {
        List<Animal> list1 = new LinkedList<>(Arrays.asList(Cat,Mouse,Dog));
        List<Animal> list2 = new LinkedList<>(Arrays.asList(Dog,Mouse,Cat));
        List<Animal> list3 = new LinkedList<>(Arrays.asList(Dog,Horse,Cat));
        List<Animal> list4 = new LinkedList<>(Arrays.asList(Dog,Tiger,Lion));

        List<List<Animal>> list = new LinkedList<>(Arrays.asList(list1, list2, list3, list4));

        Set<List<Animal>> sorted = new LinkedHashSet<>();

        for (List<Animal> animals : list) {
            List<Animal> arList = new ArrayList<>(animals);
            Collections.sort(arList);
            sorted.add(new LinkedList<>(arList));
        }

        for (List<Animal> animals : sorted) {
            System.out.println(animals);
        }
    }
}

алгоритм: сортировать отдельные списки, чтобы мы могли их сравнить. списки, такие как [cat, dog] и [dog, cat] одинаковы, но equals вернут false. теперь просто используйте HashSet. hashCode() для него будет выполнять итерацию по отдельным элементам в каждом добавлении для генерации хэша, который затем может использоваться для сравнения списков. Я использовал LinkedHashSet, чтобы восстановить исходный порядок.

Ответ 3

Попробуйте это, я создал оптимизированное решение с минимальным временем.

public class UniqueLinkedList {

    public static void main(String[] args) {
        List<String> list1 = new LinkedList<>(Arrays.asList("Cat","Mouse","Dog"));
        List<String> list2 = new LinkedList<>(Arrays.asList("Dog","Mouse","Cat"));
        List<String> list3 = new LinkedList<>(Arrays.asList("Dog","Horse","Cat"));
        List<String> list4 = new LinkedList<>(Arrays.asList("Dog","Tiger","Lion"));
        List<List<String>> list = new LinkedList<>(Arrays.asList(list1, list2, list3, list4));
        boolean flag = false;
        boolean matchFlag = true;
        for(int i = 0; i < list.size(); i++){
            for(int j = i+1; j < list.size(); j++){
                if(list.get(i).size() == list.get(j).size()){
                    matchFlag = true;
                    for(String str : list.get(i)){
                        flag = false;
                        for(String string : list.get(j)){
                            if(str.equals(string)){
                                flag = true;
                            }
                        }
                        if(flag == false){
                            matchFlag = false;
                            break;
                        }
                    }
                    if(matchFlag){
                        list.remove(j);
                        j--;
                    }
                }
            }
        }
        System.out.println(list.size());
        for(int i = 0; i < list.size(); i++){
            System.out.println(list.get(i));
        }
    }
}