劍指offer-二維數組中的查找

題目描述

在一個二維數組中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。

時間限制：1秒 空間限制：32768K 熱度指數：29783

 

個人方法：從數組每行第一個元素開始判斷是否小於或等於目標值，如果就遍歷該行

難點備註：二維數組判斷的條件

 1 public class Solution {
 2     public boolean Find(int target, int [][] array) {
 3         
 4         boolean flag=false;
 5         
 6         if(array==null||array.length==0||(array.length==1&&array[0].length==0)){
 7             return flag;
 8         }
 9         
10         for(int i=0;!flag&i<array.length;i++){
11             if(target>=array[i][0]){
12                 for(int j=0;j<array[i].length;j++){
13                     if(array[i][j]==target){
14                             flag=true;break;
15                     }
16                 }
17             }
18         }
19         
20         return flag;        
21     }
22 }

 

優秀解法：

/* 思路矩陣是有序的，從左下角來看，向上數字遞減，向右數字遞增，所以從左下角開始查找，當要查找數字比左下角數字大時。右移 要查找數字比左下角數字小時，上移*/

 1 連接：https://www.nowcoder.com/questionTerminal/abc3fe2ce8e146608e868a70efebf62e
 2 來源：牛客網
 3 
 4 class Solution { 
 5  public:
 6      bool Find(vector<vector<int> > array,int target) {
 7          int rowCount = array.size();
 8          int colCount = array[0].size();
 9          int i,j;
10          for(i=rowCount-1,j=0;i>=0&&j<colCount;)
11          {
12              if(target == array[i][j])
13                  return true;
14              if(target < array[i][j])
15              {
16                  i--;
17                  continue;
18              }
19              if(target > array[i][j])
20              {
21                  j++;
22                  continue;
23              }
24          }
25          return false;
26      }
27  };

 

連接：https://www.nowcoder.com/questionTerminal/abc3fe2ce8e146608e868a70efebf62e
來源：牛客網

兩種思路

一種是：

把每一行當作有序遞增的數組，

利用二分查找，

經過遍歷每一行獲得答案，

時間複雜度是nlogn

 1 public class Solution {
 2     public boolean Find(int [][] array,int target) {
 3          
 4         for(int i=0;i<array.length;i++){
 5             int low=0;
 6             int high=array[i].length-1;
 7             while(low<=high){
 8                 int mid=(low+high)/2;
 9                 if(target>array[i][mid])
10                     low=mid+1;
11                 else if(target<array[i][mid])
12                     high=mid-1;
13                 else
14                     return true;
15             }
16         }
17         return false;
18  
19     }
20 }

 

 

另一種思路是：

利用二維數組由上到下，由左到右遞增的規律，

那麼選取右上角或者左下角的元素a[row][col]與target進行比較，

當target小於元素a[row][col]時，那麼target一定在元素a所在行的左邊,

即col--；

當target大於元素a[row][col]時，那麼target一定在元素a所在列的下邊,

即row++；

 1 public class Solution {
 2     public boolean Find(int [][] array,int target) {
 3         int row=0;
 4         int col=array[0].length-1;
 5         while(row<=array.length-1&&col>=0){
 6             if(target==array[row][col])
 7                 return true;
 8             else if(target>array[row][col])
 9                 row++;
10             else
11                 col--;
12         }
13         return false;
14  
15     }
16 }