【剑指Offer】二维数组中的查找

于 2015-08-31 22:38:09 发布
阅读量303 收藏
点赞数
分类专栏： 算法 文章标签： 算法
本文介绍了一种在特殊排序的二维数组中查找特定整数的方法。该数组每行、每列都按递增顺序排列。文章详细阐述了如何利用这一特性进行高效搜索，包括通过最大匹配正方形对角线寻找单一递增方向、使用二分查找提高效率等技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转自：http://liuqing-2010-07.iteye.com/blog/1330830

1.1. 问题描述 
    在一个二维整数数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 
     例如下面的二维数组就是每行、每列都递增排序。如果在这个数组中查找数字7，则返回true；如果查找数字5，由于数组不含有该数字，则返回false。 

图1-1

1.2. 问题分析  
    由于数组M是一个m*n阶矩阵。矩阵M的可能情况如下： 

矩阵M的特点是： 
(1) 图中“ 红色元素 ”是以第一个元素为顶点的最大正方形对角线上的元素，这条对角线上的红色元素把矩阵的每行和每列都切割成了两部分。 
(2) 行和列都是递增数列，“红色元素”所在行的左侧都比它小，右侧都比它大；所在列的上侧都比它小，下侧都比它大。 
(3)矩阵M的第一个元素最小，最后一个元素最大。 

算法描述： 
    (1)将key分别与矩阵的最大元素和最小元素比较，如果key比矩阵的最大元素大或者比最小元素小，则无须继续查找，不存在这样的key。 
    (2)以“红色元素”为分割点，对于行数大于等于列数的矩阵采用 列二分搜索 (如图1-2和图1-4所示矩阵)。如果key等于“红色元素”返回true；比“红色元素”大在列下侧搜索；比“红色元素”小，则key只可能在图中红色箭头围成的区域中，把这样的区域称为“ 最小区域 ”。发现“最小区域”后，直接进入最小区域搜索。 
    (3)对于行数小于列数的矩阵采用 行二分搜索 (如图1-3所示矩阵)。 

行搜索算法（一行一行的二分搜索）

[java]  view plain copy
  1. boolean rowSearch(int [][] matrix,int key) {  
  2.     int row = matrix.length-1,col = matrix[0].length-1;  
  3.     int low = 0 , high = 0,mid = 0,midVal = 0,fixMin=-1;  
  4.     for (int i = 0; i <= row ; i++) {  
  5.         if(fixMin != -1) {  
  6.             low = 0;  
  7.             high = fixMin;//如果一旦发现key<matrix[i][i];则每行的high已经确定  
  8.         } else {  
  9.             if(key > matrix[i][i]) {  
  10.                 low = i+1;  
  11.                 high = col;    
  12.             } else if(key < matrix[i][i]) {  
  13.                 low = 0;  
  14.                 high = i-1;  
  15.                 fixMin = high;//发现最小区域  
  16.             } else {  
  17.                 return true;  
  18.             }     
  19.         }  
  20.         while(low <= high) {  
  21.             mid = (low + high)>>1;  
  22.             midVal = matrix[i][mid];  
  23.             if(key < midVal) {  
  24.                 high = mid -1;  
  25.             } else if (key > midVal) {  
  26.                 low = mid + 1;  
  27.             } else {  
  28.                 return true;//发现key  
  29.             }  
  30.         }                         
  31.     }  
  32.     return false;//没有发现key  
  33. }  

列搜索算法（一列一列的二分搜索）

[cpp]  view plain copy
  1. boolean colSearch(int [][] matrix,int key) {  
  2.     int row = matrix.length-1,col = matrix[0].length-1;  
  3.     int low = 0 , high = 0,mid = 0,midVal = 0,fixMin=-1;  
  4.     for (int i = 0; i <= col ; i++) {  
  5.         if(fixMin != -1) {//一旦在前一列中发现，key<matrix[i][i]，则以后的列的范围肯定是[0,fixMin]  
  6.             low = 0;  
  7.             high = fixMin;  
  8.         } else {  
  9.             if(key > matrix[i][i]) {  
  10.                 low = i+1;  
  11.                 high = row;    
  12.             } else if(key < matrix[i][i]) {  
  13.                 low = 0;  
  14.                 high = i-1;  
  15.                 fixMin = high;//发现最小区域  
  16.             } else {  
  17.                 return true;  
  18.             }     
  19.         }  
  20.         while(low <= high) {  
  21.             mid = (low + high)>>1;  
  22.             midVal = matrix[mid][i];  
  23.             if(key < midVal) {  
  24.                 high = mid -1;  
  25.             } else if (key > midVal) {  
  26.                 low = mid + 1;  
  27.             } else {  
  28.                 return true;//发现key  
  29.             }  
  30.         }                     
  31.     }  
  32.     return false;//没有发现key  
  33. }  


搜索主算法 

[cpp]  view plain copy
  1. boolean search(int [][] matrix,int key) {  
  2.     //比最小值小  
  3.     if(key<matrix[0][0]) {  
  4.         return false ;  
  5.     }  
  6.     int row = matrix.length-1,col = matrix[0].length-1;  
  7.     //比最大值大  
  8.     if(key > matrix[row][col]) {  
  9.         return false ;  
  10.     }  
  11.     if( row < col) {  
  12.         //行数小于列数采用行搜索  
  13.         return rowSearch(matrix, key);  
  14.     } else {  
  15.         //行数大于等于列数采用列搜索  
  16.         return colSearch(matrix, key);  
  17.     }  
  18. } 
【自己的思考】  

由于转载的文章，理解原作者的思维方式才是最重要的。归纳如下：

1、 矩阵横向、纵向递增，但横纵递增两者之间并没有关系，因此通过最大匹配正方形的对角线，找到单一递增方向；

2、查找效率的提高，一是体现在利用二分查找搜索；二是在最小区域的利用（例如行搜索中确定了目标比某个对角线上的元素大，目标的列下标边界必定大于该元素的列下标）；三是对于采用行搜索与列搜索的选择，由于算法时间复杂度为O(nlogn)，而n的递增趋势大于logn，应减少循环次数提高效率，因此矩阵行数小于列数时，采用行搜索

3、重新敲一遍代码，加上边界值的考虑

public class Solution {
    public boolean Find(int [][] array,int target) {
      int row = array.length;
      int col = array[0].length;
      if(col == 0) {     //如果是空数组，直接返回false
          return false;
      }
      else if((target < array[0][0]) || (target > array[row - 1][col - 1])) {   //如果target小于最小值或大于最大值，返回false
          return false;
      } else {
          if(row <= col) {
              return rowSearch(array, target, row, col);   //行数小于列数，采用行搜索
          } else {
              return colSearch(array, target, row, col);   //列数小于行数，采用列搜索
          }
      }
    }
    
    public boolean rowSearch(int[][] array, int target, int row, int col) {
        int pol = - 1;
        int low = 0;
        int high = col - 1;
        
        for(int i = 0; i < row; i++) {
            if(pol != -1) {                //标志下标，如果不为-1，代表已经找到target可能的最大列下标
                low = 0;
                high = pol;
            } else if(target < array[i][i]) {
                low = 0;
                high = i - 1;
            } else if(target > array[i][i]){
                low = i + 1;
                high = col - 1;
            } else {
                return true;
            }
            
            while(low <= high) {               //二分搜索
                int midVal = (int)(low + high) / 2;
                if(target < array[i][midVal]) {
                    high = midVal - 1;
                } else if(target > array[i][midVal]) {
                    low = midVal + 1;
                } else {
                    return true;
                }
            }
        }
        return false;
    }
    
    public boolean colSearch(int[][] array, int target, int row, int col) {
        int pol = - 1;
        int low = 0;
        int high = row - 1;
        
        for(int i = 0; i < col; i++) {
            if(pol != -1) {               //标志下标，如果不为-1，代表已经找到target可能的最大行下标</span>
                low = 0;
                high = pol;
            } else if(target < array[i][i]) {
                low = 0;
                high = i - 1;
            } else if(target > array[i][i]){
                low = i + 1;
                high = row - 1;
            } else {
                return true;
            }
            
            while(low <= high) {        //二分搜索</span>
                int midVal = (int)(low + high) / 2;
                if(target < array[midVal][i]) {
                    high = midVal - 1;
                } else if(target > array[midVal][i]) {
                    low = midVal + 1;
                } else {
                    return true;
                }
            }
        }
        return false;
    }
}


评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值