Question

我正在寻找有关此解决方案的说明。谁能在以下两点上指导我：

以下算法是好的解决方案吗？
我的Big O计算正确吗？

高度赞赏您的澄清。预先感谢

public static void main(String[] args) {
    String[] a = {"a", "b", "c", "d"};
    String[] b = {"z", "f", "c"};

    boolean value1 = find(a, b);
    System.out.println(value1);

    boolean value2 = findArray(a, b);
    System.out.println(value2);

}

/*
since the both the array is of diff size for nested loop
Big O  = O(n*n)
if array size is same Big O = O(n^2)
 */
private static boolean find(String[] a, String[] b) {
    for (int i = 0; i < a.length; i++) {
        String val1 = a[i];
        for (int j = 0; j < b.length; j++) {
            if (val1.equals(b[j])) {
                System.out.println(val1 + " : " + b[j]);

                return true;
            }
        }// O(n)
    }// O(n)
    return false;
}// O(n*n)

/*
Big O  = O(n)
 */
private static boolean findArray(String[] a, String[] b) {
    //create array list from array
    List<String> list = new ArrayList<>(Arrays.asList(b));
    for (int i = 0; i < a.length; i++) {
        String val1 = a[i]; //O(1)

        if (list.contains(val1)) {
            System.out.println(val1 + " : contain in list b");
            return true;
        }// O(1)

    }// O(n)
    return false;
}// O(n)

Answer 1

您的第二个解决方案也是O（N ^ 2），因为在幕后包含了作品O（N）。

第一个解决方案O（N * LogN）：

排序第二个数组。 NLogN
通过第二个迭代第一个O（N）和binary search 一个O（logN）=> O（NLogN）

总体复杂度O（NLogN）

第二个解决方案O（N）-如果数组已排序。如果不是O（NLogN），则由于步骤1

对两个数组O（NlogN）进行排序
做这样的事

代码：

int curA = 0, curB = 0;
while (true) {
 if (curA >= a.length || curB >= b.length)
  break;
 if (a[curA] < b[curB]) {
  curA++;
  continue;
 }

 if (a[curA] > b[curB]) {
  curB++;
  continue;
 }

 return true;
}
return false;

Answer 2

我认为这两种算法看起来都是合理的。
ArrayList。包含的时间复杂度为O（n）。

size，isEmpty，get，set，iterator和listIterator操作在恒定时间内运行。加法运算以固定的固定时间运行，也就是说，添加n个元素需要O（n）时间。 所有其他操作均在线性时间内运行（大致而言）。与LinkedList实现相比，常数因子较低。

https://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html

Java：采用2数组查找两个数组中都存在的元素是否存在，否则返回true

2 个答案: