时间戳

首页 > 解决方案 > 我想从java中的整数arraylist中删除重复的子整数arraylist

java - 我想从java中的整数arraylist中删除重复的子整数arraylist

问题描述

您将获得一个嵌套数组列表，例如： list = [[-1,2,1],[-2,-2,4],[-1,2,-1],[-1,-2,3 ],[-1,2,-1]]

我想要这样的输出：[[-1,2,1],[-2,-2,4],[-1,-2,3]]

但它不太可能与我正在使用的代码一起提供......

for(int i=0;i<list.size();i++){
for(int j=i+1;j<list.size();j++){
if(list.get(i).eqauls(list.get(j)))
 {
 list.remove(list.get(j));
  }
  }
  }
 System.out.println(list);

我已经这样做了，但它没有采取并且重复仍然存在所以我以另一种方式做了这样的事情......

List<List<Integer>> list2=  new ArrayList<List<Integer>>();
for(int i=0;i<list.size();i++){
for(int j=i+1;j<list.size();j++){
if(!list.get(i).eqauls(list.get(j)))
 {
 List<Integer> p= new ArrayList<Integer>();
 for(int m=0;m<list.size();m++){
 for(int n=0;n<list.get(i).size();n++){
 p.add(list.get(i).get(m));
 list2.add(p);
 }
 }
 }
System.out.println(list2);

输出：运行时错误在这种情况下我应该怎么做......只使用数组列表数据结构......

标签： javaarraylist

解决方案

战略

我们可以构建一个树形数据结构，其路径正是您的主列表中包含的唯一子列表。构建树后，我们可以迭代它，例如使用递归算法，并重新构建列表的主列表，没有任何重复。

代码

import java.util.*;

public class ListUnduper{

     public static void main(String []args){
        Tree root = new Tree();
        List<List<Integer>> list = new ArrayList<>();
        List<Integer> first = new ArrayList<Integer>(); 
        first.add(1); first.add(2);
        List<Integer> second = new ArrayList<Integer>(); 
        //Add more lists here if you like
        list.add(first); list.add(second);
        for(int i=0;i<list.size();i++){
          List<Integer> inner = list.get(i);
          Tree current = root;
          for(int j=i+1;j<inner.size();j++){
            int nextElement = inner.get(j);        
            if(!current.children.containsKey(nextElement)){
              current.children.put(nextElement, new Tree());
            }
            current = current.children.get(nextElement);
           }
        }

        List<List<Integer>> master = new ArrayList<List<Integer>>();
        List<Integer> emptyPrefix = new ArrayList<Integer>();
        addAllToList(emptyPrefix, master, root);    

        //master now should contain all non-dupes 
     }

    static void addAllToList(List<Integer> prefix, List<List<Integer>> master, Tree tree){
      for(Map.Entry<Integer,Tree> entry : tree.children.entrySet()){
        Tree nextTree = entry.getValue();  
        //I believe this makes a deep copy
        List<Integer> nextPrefix = new ArrayList<>(prefix);
        nextPrefix.add(entry.getKey());
        if(nextTree.children.isEmpty()){
          master.add(nextPrefix);
        }
        else{
          addAllToList(nextPrefix, master, tree);
        }
      }
    }
}

class Tree{
  HashMap<Integer, Tree> children = new HashMap<Integer, Tree>();
}

警告：如果您的列表很大，使用递归可能会导致 Stackoverflow 错误。在这种情况下，建议改用 while 循环，但在这种情况下，算法的编码可能会更复杂。

关于元素顺序的注意事项

正如这个替代答案所指出的，主列表中列表的原始顺序可能很重要。上述解决方案不保证保留这样的订单。

推荐阅读