Java 如何在没有循环嵌套的情况下扫描两个不同长度的数组？

我正在研究的Java问题如下：

给定两个按递增顺序排序的整数数组（外部和内部），如果内部的所有数字都显示在外部，则返回true。 最好的解决方案只对两个数组进行一次“线性”传递，利用了两个数组都已按排序的事实

“两个数组的单个“线性”过程”是否意味着不嵌套第二个循环就解决了问题？如果不是，请解释“线性通行证”的含义

否则，如果我对“线性传递”的解释是正确的，我现在就不知所措了。我能想出的唯一解决方案包括嵌套在第一个循环下面的第二个循环

public static boolean linearIn(int[] outer, int[] inner){
    int trueCount = 0;
    for(int i = 0; i < inner.length; i++){
        for(int x = 0; x < outer.length; x++){
            if(inner[i] == outer[x]){
                trueCount++;
                break;
            }
        }
    }
    return (trueCount == inner.length);
}

公共静态布尔线性（int[]外部，int[]内部）{
int-trueCount=0；
for（int i=0；i

不要循环内部数组的整个长度…从最后一个选中的值开始，一直循环到匹配为止。

不要循环内部数组的整个长度…从最后一个选中的值开始，一直循环到匹配为止。

在您的实现中，您循环了“外部”多次（内部.length次），因此，不会对每个阵列执行一次传递

我认为你让你自己更加困惑了。这样想一下——在检查一个数组时，您已经在跟踪您所处的索引（在示例代码中使用“i”和“x”）。为什么不使用一个来检查两个数组

---

答案故意有点模糊，因为这似乎是一个与家庭作业相关的问题。

在您的实现中，您将在“外部”上循环多次（内部.length次），因此不会在每个数组上进行一次循环

我认为你让你自己更加困惑了。这样想一下——在检查一个数组时，您已经在跟踪您所处的索引（在示例代码中使用“i”和“x”）。为什么不使用一个来检查两个数组

---

答案故意有点模糊，因为这似乎是一个与家庭作业相关的问题。

这是一个经典的面试问题。最佳答案通常涉及哈希表或映射。第一次通过“外部”数组进入哈希表。第二次传递只是检查该值是否已经在表中

public static boolean linearIn(int[] outer, int[] inner){

    HashMap<Integer, Boolean> map = new HashMap<Integer, Boolean>();

    for (int o : outer)
    {
        map.put(o, true);
    }

    for (int i : inner)
    {
        Boolean result = map.get(i);
        if ((result == null) || (result.booleanValue() == false))
        {
            return false;
        }
    }

    return true;
}

公共静态布尔线性（int[]外部，int[]内部）{
HashMap=newHashMap（）；
用于（内部o：外部）
{
map.put（o，true）；
}
for（int i：内部）
{
布尔结果=map.get（i）；
if（（result==null）| |（result.booleanValue（）==false））
{
返回false；
}
}
返回true；
}

---

上面的代码以O（N）形式运行。

这是一个典型的面试问题。最佳答案通常涉及哈希表或映射。第一次通过“外部”数组进入哈希表。第二次传递只是检查该值是否已经在表中

public static boolean linearIn(int[] outer, int[] inner){

    HashMap<Integer, Boolean> map = new HashMap<Integer, Boolean>();

    for (int o : outer)
    {
        map.put(o, true);
    }

    for (int i : inner)
    {
        Boolean result = map.get(i);
        if ((result == null) || (result.booleanValue() == false))
        {
            return false;
        }
    }

    return true;
}

公共静态布尔线性（int[]外部，int[]内部）{
HashMap=newHashMap（）；
用于（内部o：外部）
{
map.put（o，true）；
}
for（int i：内部）
{
布尔结果=map.get（i）；
if（（result==null）| |（result.booleanValue（）==false））
{
返回false；
}
}
返回true；
}

---

上面的代码以O（N）的形式运行。

我认为这里没有一个有效的答案，没有代码很难做到，但我会尝试

我认为诀窍是迭代较大的数组（外部），但保留当前“内部”的附加索引（从0开始）

当你通过外部时，如果当前外部中的对象比内部中的对象小，你就没事了，只是还没有到达下一个“内部”，所以继续

如果当前内部的对象与外部的对象相同，那么您很好，您找到了匹配项。。。您希望增加内部的索引并继续

如果当前外部中的对象大于当前内部中的对象，那么您错过了一个（外部中不存在一个内部对象），那么您就完成了--返回false

如果你到达循环的终点，那么你就通过了所有的循环，你知道内在的每一个都在外在

这样，它将自动跳过不在内部的“外部”条目。失败的唯一方法是当一个外部大于当前内部时，如果存在一个与当前内部相同的外部，则会增加内部的索引并继续

---

如果这让人困惑，我很抱歉，正如我所说，使用代码要容易得多，但我觉得为学习型问题输入代码真的很糟糕。

我认为这里没有一个答案很有效，没有代码很难做到，但我会尝试

我认为诀窍是迭代较大的数组（外部），但保留当前“内部”的附加索引（从0开始）

当你通过外部时，如果当前外部中的对象比内部中的对象小，你就没事了，只是还没有到达下一个“内部”，所以继续

如果当前内部的对象与外部的对象相同，那么您很好，您找到了匹配项。。。您希望增加内部的索引并继续

如果当前外部中的对象大于当前内部中的对象，那么您错过了一个（外部中不存在一个内部对象），那么您就完成了--返回false

如果你到达了循环的终点，那么你就通过了所有的循环，你知道内在的每一个都在你里面