二维数组中的查找

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. }