Java 数组搜索的时间复杂度

我编写函数是为了检查给定值是否包含在中的矩阵中。此矩阵具有以下属性： •每行中的整数按从左到右的升序排序。 •每列中的整数按从上到下的升序排序

public static boolean searchMatrix(int target, int[][] matrix)
{
    for(int i = 0;i <= matrix[0].length;i++)
    {
        for (int j=i; j<matrix.length;j++)
        {
        if(target == matrix[i][j])
        return true;
        }
    }
    return false;
}

公共静态布尔搜索矩阵（int目标，int[][]矩阵）
{
对于（int i=0；i您编写它的方式（蛮力计算）的最坏情况时间复杂度为O（N^2）。由于您说数组已排序，您可以改为实现最坏情况时间复杂度为N（2*log（N））。
假设一个nx m矩阵，您的算法为O（N*m），因为它（可能）迭代所有行和列（即所有元素）

然而，存在一个算法是O（log（m+n））

因为这是一个在线编码面试（我是通灵者），我只给你一些提示：


给定坐标（x，y）处的元素，如何知道目标可能在哪里
如果你分别治疗x和y，你会怎么做
我认为搜索可以在线性时间内完成。把下面的4×4矩阵视为：

1 2 4 6
2 3 5 7      ascending from left to right
3 4 6 8      and from top to bottom
4 5 6 9

如果我们正在搜索值
5
，我们可以从左上角开始，然后向右走，直到找到值，或者遇到一个大于目标值5的数字。在这种情况下，我们点击6。然后，我们可以回滚到4，并前进到更高的行。可以保证第一行小于目标，并且从该列开始的下一行中的每个值都大于第一行上的值

这是一个大致线性的方法。一个很好的类比是绕着山的周长行走，寻找一定的海拔高度。如果在每个点上我们要么找不到我们想要的高度，要么只找到太高的点，我们就继续行走。
如前所述，对于方阵，你的算法是O（N*M）或O（N^2）

您可以使用单个循环来完成此操作：

基本上从右上角开始检查单元格，如果数字太大，则向左移动，如果数字太小，则向下移动。如果从两边的边缘掉下，则数字不存在

boolean searchMatrix(int target, int[][] mat)
{
   int i = 0, j = mat[0].length;
   while (i < mat.length && j >= 0)
   {
      if (mat[i][j] == target)
      {
         return true;
      }
      else if (mat[i][j] < target)
      {
         i++;
      }
      else
      {
         j--;
      }
   }
   return false;
}

布尔搜索矩阵（int目标，int[]mat）
{
int i=0，j=mat[0]。长度；
而（i=0）
{
if（mat[i][j]==目标）
{
返回true；
}
如果（mat[i][j]<目标）
{
i++；
}
其他的
{
j--；
}
}
返回false；
}
如果你说矩阵是排序的，你可以使用二进制搜索来找到目标。使用两个单独的单层循环，首先搜索行，然后搜索列。它是o（N/2）。
一般来说，如果循环中的语句是
o（1）
，一个循环是
o（N）
，两个循环有一个嵌套的是
o（N^2）
或
o（N*m）
。假设这个t将帮助你更清楚地理解时间复杂性的概念。@SpencerWieczorek只是好奇地问。给定的矩阵已经是2d数组，这意味着
n是双数组行*列的大小
，所以即使使用嵌套循环，它也不会是
O（n）
因为循环将循环
n
time？在最坏的情况下，嵌套循环将在矩阵[i]中的每个元素上完整运行一次，因此它是O（n^2）假设是平方矩阵，这一切都取决于你如何定义
N
是什么，但通常你希望它是一个线性缩放的东西。声明
N=row*col
意味着你可以声明它是
O（N）
，它与矩阵行和列的大小不成线性关系。嗨，格伦，请告诉我我的答案有什么问题。我想我的回答是对的，但我现在在手机上。@tim你的算法是O（n），但你可以在O（log n）中完成它如果不是从左上开始，你会在中间发生什么？波希米亚，我不知道你是如何覆盖所有可能性的，因为行的值可能与列的顺序不一致。我想把矩阵分解成当前中间的4个子矩阵，但是在每一步中，你只能去掉4个矩阵中的1个。必须搜索另一个3。对，我们可以使用分而治之的方法，有一点合并排序的味道。在这种情况下，我们将从中间开始，然后决定是否需要更高或更低。再次，我们将在那个部分的中间着陆，然后重复。这是代码> O（n LGN）。

@tim是的。找出目标在哪个象限，然后递归调用是最简单的方法。注意：

O（N/2）

与

O（N）

相同。是的，你是对的。但是我认为这是一个符合要求的不错的实现。这个程序的复杂度是O（N）吗@twain249最坏的情况是，你必须向左走N-1，然后向下走M-1，所以它是O（M+N-2），或者对于NxN O（2N-2），它是O（N）。