剑指offer - 二维数组中的查找

题目

在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一共函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数

例如下面的二维数组就是每行、每列都递增排序。如果在这个数组中查找数字7，则返回true，如果查找数字5，由于数组不含有该数字，则返回false

1 2 8 9 
2 4 9 12
4 7 10 13
6 8 11 15

分析

1.jpg

首先我们选取数组右上角的数字9，由于9大于7，并且9还是第4列的第一个（也是最小的）数字，因此7不可能出现在数字9所在的列。于是我们把这一列从需要考虑的区域内剔除，之后需要分析剩下的3列。

在所剩下的矩阵中，位于右上角的数字是8，同样8大于7，因此8所在的列我们也可以剔除。接下来我们只要分析剩下的2列即可。

在剩下的2列中，数字2位于数组的右上角，2小于7，那么要查找的7可能在2的右边也可能在下边，在前面的步骤中，我们已经将2右边的列都已经被剔除了，也就是说2只能是出现在2的下边，于是我们把2所在的行剔除。在剩下的数字中，数字4位于又上角，由于4小于7，同样剔除4所在的行。

在剩下的2行中，位于右上角的数字7正好是我们要查找的，于是查找过程结束。

总结上面查找的过程

我们可以发现规律，首先选取数组中右上角的数字，如果该数字等于要查找的数字，则查找结束；如果该数字大于要查找的数字，则剔除这个数字所在的列；如果该数字小于要查找的数字，则剔除数字所在的行。

也就是说，如果要查找的数字不在数组的右上角，则每一次都在数组的查找范围剔除一行或者一列，这样每一步都可以缩小查找的范围，直到找到要查找的数字，或者查找范围为空

算法从右上角元素开始比较

如果相等就返回；如果大于则列减少，否则行增加

bool Find(int* matrix, int rows, int columns, int number)
{
    bool found = false;

    if(matrix != nullptr && rows > 0 && columns > 0)
    {
        int row = 0;
        int column = columns - 1;
        while(row < rows && column >=0)
        {
            if(matrix[row * columns + column] == number) // 使用指针获取二维数组的值进行比较
            {
                found = true;
                break;
            }
            else if(matrix[row * columns + column] > number)
                -- column;
            else
                ++ row;
        }
    }

    return found;
}

二维数组在内存中占据连续的空间，在内存中从上到下存储各行元素，在同行中按照从左到右的顺序存储，因此我们可以根据行号和列号计算出相当于数组首地址的偏移量

使用二维数组

bool find(int target, vector<vector<int>> array)
{
   int rows = array.size();     // 矩阵行
   int cols = array[0].size();  // 矩阵列数
   bool found = false;
   if (rows > 0 && cols > 0)
   {
       int row = 0;        // 第一行
       int col = cols - 1; // 最后一列
       while (row < rows && col >= 0) {
           if (array[row][col] == target) // 当前值跟目标值相等正好找到
           {
             found = true;
             break;
           }
           else if (array[row][col] > target) // 当前值比目标值大
                 --col;
            else
                 ++row;
            }
        }
        return found;
 }

算法从左下角开始比较

相等就返回；若大于则列增加，否则行减少

bool find1(int target, vector<vector<int>> array)
{
   int rows = array.size();
   int cols = array[0].size();
   bool found = false;
   if (rows > 0 && cols > 0)
   {
       int row = rows - 1; // 最后一行
       int col = 0;                  // 第一列
       while (row >= 0 && col < cols)
       {
          if (array[row][col] == target)
          {
               found = true;
               break;
           }
          else if (array[row][col] > target)
               --row;
          else
               ++col;
         }
      }
        return found;
  }

暴力解法，两层for循环

bool Find(vector<vector<int> > array,int target)
{
    int row = 0, col = 0, t = 0;
    bool isFound = false;

    for(int i = 0; i < array.size( ) ; ++i)
    {
        for(int j = 0; j < array[i].size( ); ++j)
        {
            //边输入边验证
            if(false == isFound && target == array[i][j])
            {
                //已经找到后就没必要再找了
                isFound = true;
            }
         }
     }
     return isFound;
}

参考

《剑指offer》