Searching a 2D Sorted Matrix Part II

最新推荐文章于 2017-04-26 11:16:16 发布

翻译最新推荐文章于 2017-04-26 11:16:16 发布 · 725 阅读

收录于

数据结构&算法

数学

本文介绍在二维整型矩阵中查找特定元素的三种方法：阶梯搜索、分治法及二分查找，并详细阐述了每种方法的实现过程及其时间复杂度。

二维整型矩阵Table [m][n]. 满足

Table[i][j] ≤ Table[i][j + 1],

Table[i][j] ≤ Table[i + 1][j]

在此中进行查找元素。

1.阶梯搜索

从右上角或者左下角开始，如下图红线所示的查找13的过程

bool stepWise(int mat[][N_MAX], int N, int target, 
              int &row, int &col) {
  if (target < mat[0][0] || target > mat[N-1][N-1]) return false;
  row = 0;
  col = N-1;
  while (row <= N-1 && col >= 0) {
    if (mat[row][col] < target) 
      row++;
    else if (mat[row][col] > target)
      col--;
    else
      return true;
  }
  return false;
}

时间复杂度O（m+n）。

2.分治法

取矩阵的中心，将其划分成如下四个部分

如果查21，由于21》9，所以黄色部分排除。

复杂度推导

 T(n) = 3T(n/2) + c, 
      = 3 [ 3T(n/4) + c] + c 
      = 3 [ 3 [ 3T(n/8)  + c ] + c] + c 
      = 3^k T(n/2^k) + c (3^k - 1)/2   
      = 3^k( T(n/2^k) + c ) - c/2


 Setting k = lg n,  
 T(n)  = 3^lgⁿ ( T(1) + c ) - c/2 
       = O(3^lgⁿ) 
       = O(n^{lg 3})           <== 3^lgⁿ = n^{lg 3} 
       = O(n^1.58)

代码：

bool quadPart(int mat[][N_MAX], int M, int N, int target, int l, int u, int r, int d, int &targetRow, int &targetCol) {
  if (l > r || u > d) return false;
  if (target < mat[u][l] || target > mat[d][r]) return false;
  int col = l + (r-l)/2;
  int row = u + (d-u)/2;
  if (mat[row][col] == target) {
    targetRow = row;
    targetCol = col;
    return true;
  } else if (l == r && u == d) {
    return false;
  }
  if (mat[row][col] > target) {
    return quadPart(mat, M, N, target, col+1, u, r, row, targetRow, targetCol) || 
           quadPart(mat, M, N, target, l, row+1, col, d, targetRow, targetCol) ||
           quadPart(mat, M, N, target, l, u, col, row, targetRow, targetCol);
  } else {
    return quadPart(mat, M, N, target, col+1, u, r, row, targetRow, targetCol) || 
           quadPart(mat, M, N, target, l, row+1, col, d, targetRow, targetCol) ||
           quadPart(mat, M, N, target, col+1, row+1, r, d, targetRow, targetCol);
  }
}
 
bool quadPart(int mat[][N_MAX], int N, int target, int &row, int &col) {
  return quadPart(mat, N, N, target, 0, 0, N-1, N-1, row, col);
}

3.二分查找

用下面的方法可以将查找范围缩小到剩余的两部分。

 a_i < s < a_i+1 ,  

 where a_i is the i^th traversed cell.

a) 基于行的划分. The highlighted gray cells represents the traversed row (the middle row). The target 10 is found between 9 and 16.

b)基于列的划分. The highlighted gray cells represents the traversed column (the middle column). The target 10 is found between 9 and 14.

c) 基于对角线的划分. The highlighted gray cells represents the traversed diagonal. The target 10 is found between 9and 17. Please note that diagonal-based binary partition would fail in a non-square matrix (for the above example, it will not work in the two sub-matrices because they are non-square matrices).

If the target element equals one of the traversed cells, we immediately return the element as found. Otherwise we partition the matrix into two sub-matrices following the partition point we found. As it turns out, we need cn time (linear time) to find such partition point, since we are essentially performing a linear search. Therefore, the complexity could be written as the following recurrence relation: (Note: I omitted the proof, as it is left as an exercise to the reader. )

复杂度：

 T(n) = 2T(n/2) + cn
      = O(n lg n)

 
  
   bool
    
   binPart
   (
   int
    
   mat
   [
   ]
   [
   N_MAX
   ]
   ,
    
   int
    
   M
   ,
    
   int
    
   N
   ,
    
   int
    
   target
   ,
    
   int
    
   l
   ,
    
   int
    
   u
   ,
    
   int
    
   r
   ,
    
   int
    
   d
   ,
    
   int
    
   &
   targetRow
   ,
    
   int
    
   &
   targetCol
   )
    
   {
  
  
     
   if
    
   (
   l
    
   >
    
   r
    
   ||
    
   u
    
   >
    
   d
   )
    
   return
    
   false
   ;
  
  
     
   if
    
   (
   target
    
   <
    
   mat
   [
   u
   ]
   [
   l
   ]
    
   ||
    
   target
    
   >
    
   mat
   [
   d
   ]
   [
   r
   ]
   )
    
   return
    
   false
   ;
  
  
     
   int
    
   mid
    
   =
    
   l
    
   +
    
   (
   r
   -
   l
   )
   /
   2
   ;
  
  
     
   int
    
   row
    
   =
    
   u
   ;
  
  
     
   while
    
   (
   row
    
   <=
    
   d
    
   &&
    
   mat
   [
   row
   ]
   [
   mid
   ]
    
   <=
    
   target
   )
    
   {
  
  
       
   if
    
   (
   mat
   [
   row
   ]
   [
   mid
   ]
    
   ==
    
   target
   )
    
   {
  
  
         
   targetRow
    
   =
    
   row
   ;
  
  
         
   targetCol
    
   =
    
   mid
   ;
  
  
         
   return
    
   true
   ;
  
  
       
   }
  
  
       
   row
   ++
   ;
  
  
     
   }
  
  
     
   return
    
   binPart
   (
   mat
   ,
    
   M
   ,
    
   N
   ,
    
   target
   ,
    
   mid
   +
   1
   ,
    
   u
   ,
    
   r
   ,
    
   row
   -
   1
   ,
    
   targetRow
   ,
    
   targetCol
   )
    
   ||
  
  
            
   binPart
   (
   mat
   ,
    
   M
   ,
    
   N
   ,
    
   target
   ,
    
   l
   ,
    
   row
   ,
    
   mid
   -
   1
   ,
    
   d
   ,
    
   targetRow
   ,
    
   targetCol
   )
   ;
  
  
   }
  
  
    
  
  
   bool
    
   binPart
   (
   int
    
   mat
   [
   ]
   [
   N_MAX
   ]
   ,
    
   int
    
   N
   ,
    
   int
    
   target
   ,
    
   int
    
   &
   row
   ,
    
   int
    
   &
   col
   )
    
   {
  
  
     
   return
    
   binPart
   (
   mat
   ,
    
   N
   ,
    
   N
   ,
    
   target
   ,
    
   0
   ,
    
   0
   ,
    
   N
   -
   1
   ,
    
   N
   -
   1
   ,
    
   row
   ,
    
   col
   )
   ;
  
  
   }