Question

我想知道什么是更好的解决方案，从两个阵列打印独特的项目时，可以产生比O(n^2)更低的复杂性。有什么想法吗？

    int[] a = {1,2,4,5,8};
    int[] b = {3,2,5,7,8};

    ArrayList unMatch = new ArrayList() ;
    for(int i=0; i<a.length; i++){
        boolean contains = false;
        innerloop:
            for(int k =0; k<b.length; k++){
                if(a[i]==b[k]){
                    contains = true;
                    break innerloop;
                }
            }
        if(!contains){
            unMatch.add(a[i]);
        }

    }
    for(int i=0; i<b.length; i++){
        boolean contains = false;
        innerloop:
        for(int k =0; k<a.length; k++){
            if(b[i]==a[k]){
                contains = true;
                break innerloop;
            }
        }
        if(!contains){
            unMatch.add(b[i]);
        }
    }

输出：[1,4,3,7]

Answer 1

如果您可以使用其他数据结构，我认为这种解决方案会更好：

首先，我们将填写HashMap<Integer, Integer>项目及其频率：

public static Set<Entry<Integer, Integer>> fillMap(int[] a, int[] b) {
    HashMap<Integer, Integer> entries = new HashMap<>();    
    for (Integer i : a) 
        entries.put(i, entries.get(i) == null ? 1 : entries.get(i) + 1);

    for (Integer i : b) 
        entries.put(i, entries.get(i) == null ? 1 : entries.get(i) + 1);

    return entries.entrySet();
}

然后打印唯一的项目（值为1的项目）：

for (Entry<Integer, Integer> entry: fillMap(a, b)) 
    if (entry.getValue() == 1) 
        System.out.println("This value is unique: " + entry.getKey() );

如果我没弄错的话，这应该在 O(n+m) （或者只是 O(n) 中运行，如果数组总长度相同的话）。

Answer 2

将数组转换为数组列表

List<Integer> c = Array.asList(a);
List<Integer> d = Array.asList<b>;
c.removeAll(d);
c.addAll(d);
c.froEach(System.out::println);

我在使用lambdas的java中做到了这只是O（n）

希望此代码能够回答您的问题

Answer 3

使用Set可以降低您的复杂性。设置不允许重复。集合可以是：

HashSet - 使用哈希表实现HashSet。元素没有订购。 [ExceptionHandler] public class HomeController : BaseController { }，[ExceptionHandler] public ActionResult index() { return Json(); }和add方法具有恒定的时间复杂度O（1）。
LinkedHashSet - 使用树（RB-Trees）。元素没有订购。相同方法的复杂性是O（log n）
TreeSet - 使用一个哈希表，其中包含一个贯穿它的链表。元素是有序的。相同方法的时间复杂度为O（1）。

E.g。

remove

因此，它在此提供线性顺序 - O（n + m）。

从两个数组中查找唯一项

3 个答案: