每日一题（daythree）

每日一题（daythree）

​ 二维数组中的查找

​ 题目介绍： 在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

解题思路

• 首先题目中给出了在二维数组中自上到下和自左到右都是递增，这时我首先想到的就是二分查找
• 把二维数组看成两个一维数组，即外层为一维数组，一维数组元素为一维数组
  1. 通过遍历外层一维数组，获取内层数组
  2. 调用Arrays的binarySearch方法进行查找
  3. 如果返回结果为负数表示未找到
• for循环执行结束如果没有结束函数表示未找到

代码实现

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        for (int i = 0; i <matrix.length ; i++) {
            if (Arrays.binarySearch(matrix[i],target)>=0) {
                return true;
            }
        }
        return false;
    }
}

这种写法的时间复杂度为O(m logn),空间复杂度为O(1)

代码优化写法

class Solution {
    public boolean findNumberIn2DArray ( int[][] matrix, int target) {
        
        //根据题目信息，二维数组中自上而下和自左到右都是递增，可以考虑从右上角进行遍历
        if (matrix.length==0||matrix[0].length==0)
        {
            return false;
        }
        int rows=matrix.length;
        int columns=matrix[0].length;
        int row=0;
        int column=columns-1;
        
        while(row<rows&&column>=0)
        {
            if (matrix[row][column]<target)
            {
                row++;
            }
            else if (matrix[row][column]==target)
            {
                return true;
            }
            else column--;
        }
        return false;
    }
}

从右上角进行遍历，为什莫从右上角进行遍历比较呢，因为在右上角的数据元素比它小的只在它左边。比它大的只在它下边，可以利用这一点进行列数和行数的变化。

通过循环结束条件需要满足二维数组下标要求，不能越界，该方法最大遍历次数为rows+columns,即m+n，所以时间复杂度为O（m+n）,该方法为力扣官方解法。

---

​

旋转数组的最小数字

题目介绍： 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为 1。 注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

解题思路

• 首先想到的是最小元素的左边元素一定大于最小元素，否则就是全相等。

代码实现

class Solution {
public int minArray(int[] numbers) {
        
        for (int i=0;i<numbers.length-1;i++)
        {
            if (numbers[i]>numbers[i+1])
            {
                return numbers[i+1]; 
            }
        }
        return numbers[0];
    }
}

时间复杂度为O(n),空间复杂度为O(1).

代码优化

class Solution {
    public int minArray(int[] numbers) {
        int low = 0;
        int high = numbers.length - 1;
        while (low < high) {
            int pivot = low + (high - low) / 2;
            if (numbers[pivot] < numbers[high]) {
                high = pivot;
            } else if (numbers[pivot] > numbers[high]) {
                low = pivot + 1;
            } else {
                high -= 1;
            }
        }
        return numbers[low];
    }
}

通过二分查找去寻找A最小值，中间索引值和最右边值进行比较，这里尽量不要对最左边值进行比较，因为左边考虑的情况较多

该方法时间复杂度为O(logn)。

---

​ 这里如果对最左边进行比较，通过简单大小于号的改变不能得到结果。因为对左边进行比较，当num[pivot]>num[left]时，直接left=middle会忽略一种情况，即该数组就是从小到大的，这时会漏掉numbers[0]这个正确结果。同时，当num[pivot]==num[left]时，直接进行left++操作也会忽略掉只有两个数组元素的情况，pivot既是left本身，这时进行自加操作，结果会错误i。