01 在递增[下面的<上面的, 左边的<右边的]二维数组中查找给定的值

前言

本博文部分图片, 思路来自于剑指offer 或者编程珠玑

问题描述

满足条件的矩阵

思路

书中给出的思路有两种

思路一 : 从第一行开始进行查找, 因为每一行的数据有序, 所以可以使用二分查找, 剪枝条件为给定的数据小于给定行的第一个数字[给定行最小的]

思路二 : 从arr[0][col-1]开始查找, arr[0][col-1]的特征为当前行的其他数据都小于该数据, 当前列的其他数据都大于该数据, 这就为我们构造了两个剪枝迭代的条件

1 如果给定的数字大于arr[0][col-1] 则可以剪去当前行[row ++]

2 如果给定的数字小于arr[0][col-1] 则可以剪去当前列[col –]

arr[0][col-1]

参考代码

/**
* file name : Test22FindNumberInTwoDimen.java
* created at : 10:48:18 AM Jun 4, 2015
* created by 970655147
*/

package com.hx.test04;

public class Test22FindNumberInTwoDimen {

// 从二维数组[左边的小于右边的, 上面的小于小面的]中找到一个数         from 剑指offer  page40
public static void main(String []args) {

int[][] arr = {
{1, 2, 8, 9 },
{2, 4, 9, 12 },
{4, 7, 10, 13 },
{6, 8, 11, 15 }
};
int tar = 11;

findNumberInArr01(arr, tar);
findNumberInArr02(arr, tar);
findNumberInArr03(arr, tar);

}

// 思路 : 一行一行的找, 剪枝条件 : 第一个元素大于tar
public static void findNumberInArr01(int[][] arr, int tar) {
for(int row=0; row<arr.length; row++) {
if(arr[row][0] > tar) {
break ;
} else {
int col = binarySearch(arr[row], tar);
if(col != -1) {
Log.log(row, col);
}
}
}
}

// binarySearch
private static int binarySearch(int[] arr, int tar) {
int low = 0, high = arr.length - 1, mid;

while(low <= high) {
mid = (low + high) >> 1;
if(arr[mid] > tar) {
high = mid - 1;
} else if(arr[mid] < tar) {
low = mid + 1;
} else {
return mid;
}

}

return -1;
}

// 思路 : 初始row为0, col为arr[0].length-1
// 遍历条件 : row小于arr.length 并且col大于等于0      否则视为找不到
// 如果当前元素小于tar  则可以剔除当前行[当前行的元素均小于当前元素]
// 如果当前元素大于tar  则可以剔除当前列[当前列的元素均大于当前元素]
// 否则  找到目标元素
public static void findNumberInArr02(int[][] arr, int tar) {
int row = 0, col = arr[0].length - 1;

while(row < arr.length && col >= 0) {
if(arr[row][col] > tar) {
col --;
} else if(arr[row][col] < tar) {
row ++;
} else {
Log.log(row, col);
break;
}
}
}

// 思路 和前面一种方法差不多, 不过初始位置不一样, 导致了逻辑有一些差别
public static void findNumberInArr03(int[][] arr, int tar) {
int row = arr.length - 1, col = 0;

while(row < arr.length && col >= 0) {
if(arr[row][col] > tar) {
row --;
} else if(arr[row][col] < tar) {
col ++;
} else {
Log.log(row, col);
break;
}
}

}

}

效果截图

总结

对于思路一 : n * n的矩阵中, 需要计算n次二分查找, 每一次时间复杂度为log(n), 总的时间复杂度为O(nlog(n) ), 假设剪枝减掉一半, 复杂度为O((1 /2) nlog(n) ), 忽略掉常数项, 时间复杂度依然为O(nlog(n) )

对于思路二 : n * n的矩阵中, 因为每一次迭代, 都必然剪去一行, 或者一列, 所以最多的尝试次数为n次, 时间复杂度为O(n)

注 : 因为作者的水平有限，必然可能出现一些bug, 所以请大家指出！