题目：
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
示例:
现有矩阵 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回true。
给定target = 20，返回false。
限制：
0 <= n <= 1000
0 <= m <= 1000
三种解法
public class Algorithm {
/**
* @描述： 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数
* @思路一： 最笨的方法，直接使用2层循环，时间复杂度O(mn)
* @思路二： 利用二维数组由上到下，由左到右递增的规律，那么选取左下角或者右上角的元素a[i][j]与target进行比较，如果target > array[i][j]时，target必定在array[i][j]下边，j++，如果target < array[i][j]时，target必定在array[i][j]左边，i--；时间复杂度O(m+n)
* @思路三： 每一行都按照从左到右递增的顺序排序，把每一行看作有序递增数组，利用二分查找，通过遍历每一行查找得到答案，时间复杂度mlog(n)
*/
public boolean findNumberIn2DArray1(int[][] array, int target) {
if (array.length == 0 || array[0].length == 0) {
return false;
}
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
if (target == array[i][j]) {
return true;
}
}
}
return false;
}
/**
* 选取右上角元素与目标元素做比较
* 如果target > array[i][j]时，target必定在array[i][j]下边，j++
* 如果target < array[i][j]时，target必定在array[i][j]左边，i--
*
* @param array
* @param target
* @return
*/
public boolean findNumberIn2DArray2(int[][] array, int target) {
if (array.length == 0 || array[0].length == 0) {
return false;
}
int i = array.length - 1;
int j = 0;
while (i >= 0 && j < array[0].length) {
if (target > array[i][j]) {
j++;
} else if (target < array[i][j]) {
i--;
} else {
return true;
}
}
return false;
}
/**
* 利用二分查找
* 时间复杂度mlog(n)
*
* @param array
* @param target
* @return
*/
public boolean findNumberIn2DArray3(int[][] array, int target) {
if (array.length == 0 || array[0].length == 0) {
return false;
}
for (int i = 0; i < array.length; i++) {
int begin = 0;
int end = array[i].length - 1;
while (begin <= end) {
int mid = (begin + end) / 2;
if (target > array[i][mid]) {
begin = mid + 1;
} else if (target < array[i][mid]) {
end = mid - 1;
} else {
return true;
}
}
}
return false;
}
}
Test
public class AlgorithmTest {
@Test
public void testFindFromTwoDimensionalArray1() {
Algorithm algorithm = new Algorithm();
int[][] arr = new int[][]{{1, 3, 7, 8}, {11, 43, 66, 88}, {89, 99, 111, 333}};
Long start1 = System.nanoTime();
System.out.println(algorithm.FindFromTwoDimensionalArray1(arr, 66));
System.out.println(algorithm.FindFromTwoDimensionalArray1(arr, 77));
System.out.println(algorithm.FindFromTwoDimensionalArray1(arr, 8));
Long end1 = System.nanoTime();
System.out.println("time used: " + (end1 - start1));
System.out.println("===============================================");
Long start2 = System.nanoTime();
System.out.println(algorithm.FindFromTwoDimensionalArray2(arr, 66));
System.out.println(algorithm.FindFromTwoDimensionalArray2(arr, 77));
System.out.println(algorithm.FindFromTwoDimensionalArray2(arr, 8));
Long end2 = System.nanoTime();
System.out.println("time used: " + (end2 - start2));
System.out.println("===============================================");
Long start3 = System.nanoTime();
System.out.println(algorithm.FindFromTwoDimensionalArray3(arr, 66));
System.out.println(algorithm.FindFromTwoDimensionalArray3(arr, 77));
System.out.println(algorithm.FindFromTwoDimensionalArray3(arr, 8));
Long end3 = System.nanoTime();
System.out.println("time used: " + (end3 - start3));
}
}
输出
false
true
time used: 137101
===============================================
true
false
true
time used: 40600
===============================================
true
false
true
time used: 39299
