D2 个人整理输出

自己思考了很久尝试了几种写法，总是会漏掉一些边边角角没有考虑到：

1. 尝试（左上角开始）：

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int rowN = matrix.length;
        int colN = matrix[0].length;
        if(matrix[rowN-1][colN-1] < target || matrix[0][0] > target){
            return false;
        }
        //从左上角开始判断
        int col = 0;
        int row = 0;
        while(matrix[row][col] <= target){
            if(matrix[row][col] == target){
                return true;
            }
            //判断此时col，row是否处于边界
            if(col == colN-1){
                //无法再横向移动，此时只能增加row值
                row++;
            }else if(row == rowN-1){
                //无法再纵向移动，此时只能增加col值
                col++;
            }else{
                row++;
                col++;
            }
        }
        //当matrix[row][col] > target时跳出，此时target只可能出现在此时的col，row边上
        for(int i = 0; i < row; i++){
            if(matrix[i][col] == target){
                return true;
            }
        }
        for(int j = 0; j < col; j++){
            if(matrix[row][j] == target){
                return true;
            }
        }
        return false;
    }
}

        本以为能通过，结果在下边这个用例中翻车了，

int[][] m = {{1, 2, 3, 4, 5},
            {6, 7, 8, 9, 10},
            {11, 12, 13, 14, 15},
            {16, 17, 18, 19, 20},
           {21, 22, 23, 24, 25}};            target = 15

还是混淆了矩阵中数字大小的位置关系，如我上述代码中的推导，所得出的row与col只能说明target不在以matrix[row][col]所在的点所分出的左上以及右下的两个对角矩阵里（可能在剩余的右上&左下的两个矩阵里），如此的话需要的判断就变成了两个方阵，更复杂了。。。显然思路有问题。

2. 换个方向（左下开始）：

class Solution {
        public boolean searchMatrix(int[][] matrix, int target) {
        int col = 0;//列
        int row = matrix.length - 1;//行
        int colN = matrix[0].length;
        //从左下角开始找
        while (row >= 0 && col < colN) { //不越界就能一直找
            if (target == matrix[row][col]) {
                return true;
            } else if (target < matrix[row][col]) { //往上走，找matrix中更小的值
                row--;
            } else if (target > matrix[row][col]) {//往右拐，找matrix中更大的值
                col++;
            }
        }
        return false;
    }
}

        此时的判断路径更明确，左下角开始，大了往上走（右边的数肯定更大，因此不在考虑范围内），小了往右走（此数上面的数肯定更小）。明显思路更清晰了，good。（受启发：左下角类似于二叉树中的头节点，往上找相当于往左子树走，往右找相当于往右子树走）。

补充一下评论区的解法：

从右上角开始：

    public boolean searchMatrix(int[][] matrix, int target) {
        //从矩阵右上角开始搜索
        int col = matrix[0].length - 1;//列
        int row = 0;//行

        while (col >= 0 && row <= matrix.length - 1) {
            if (target == matrix[row][col]) {
                //如果找到就直接返回
                return true;
            } else if (target < matrix[row][col]) {
                //如果查找的值大了，下一步往左找
                col--;
            } else if (target > matrix[row][col]) {
                //如果查找的值小了，下一步往下找
                row++;
            }
        }
        return false;
    }

力扣

从矩阵的右上角开始找，

1，如果找到就直接返回

2，如果没找到就继续查找

• 如果查找的值小于target就往下找
• 如果查找的值大于target就往左找。

可见其思路和“从左下角开始”一致，也是一棵二叉树~