1027刷题小结

二维数组中的查找

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

//二维数组a[][]
//1.行数
a.length
//2.列数
a[0].length

也就是对每一行使用折半二分查找

public boolean findNumberIn2DArray(int[][] matrix, int target) {
        for(int i=0;i<matrix.length;i++){
            int low = 0;
            int high = matrix[i].length-1;
            while(low<=high){
                int middle = (low+high)/2;
                if(target==matrix[i][middle]){
                    return true;
                }else if(target<matrix[i][middle]){
                    high=middle-1;
                }else if(target>matrix[i][middle]){
                    low=middle+1;
                }
            }
        }
        return false;
    }

也可以利用给定的二维数组每行从左到右递增，每列从上到下递增的特点，当访问到一个元素时，可以排除数组中的部分元素，从右上角开始二分查找，如果当前元素等于目标值，则返回 true。如果当前元素大于目标值，则移到左边一列。如果当前元素小于目标值，则移到下边一行。

public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int rows = matrix.length, columns = matrix[0].length;
        int row = 0, column = columns - 1;
        while (row < rows && column >= 0) {
            int num = matrix[row][column];
            if (num == target) {
                return true;
            } else if (num > target) {
                column--;
            } else {
                row++;
            }
        }
        return false;
    }

---

青蛙跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：2

示例 2：

输入：n = 7
输出：21

示例 3：

输入：n = 0
输出：1

我们可以想到，前往楼梯顶部的最后一步，要么跳两阶，要么跳一阶；所以根据这个思路，跳n阶的方法数=跳n-1阶的方法数+跳n-2阶的方法数，也就是
$$f(n)=f(n-1)+f(n-2)$$
这也就是我们熟悉的斐波那契数列！！！！神奇！！！

public int numWays(int n) {
        int a=1,b=1,sum;
        for(int i=0;i<n;i++){
            sum=(a+b)%1000000007;
            a=b;
            b=sum;
        }
        return a;
    }

---

旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

示例 1：

输入：[3,4,5,1,2]
输出：1

示例 2：

输入：[2,2,2,0,1]
输出：0

自然而然暴力法：

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(logN),空间复杂度为O(1)。

public int findMin(int[] nums) {
        int low = 0;
        int high = nums.length - 1;
        while (low < high) {
            int pivot = low + (high - low) / 2;
            if (nums[pivot] < nums[high]) {
                high = pivot;
            } else {
                low = pivot + 1;
            }
        }
        return nums[low];
    }

二分查找的mid值的计算：

mid=(low+high)/2;

但是这种写法可能会因为low和high比较大而引发溢出，下面是改进：

mid=low+(high-low)/2

更进一步，如果要将性能优化到极致就将除法转为位运算，因为相比除法来说，计算机处理位运算要快得多！

mid=low+((high-low)>>1);

很大的数，不适合数组，数组是连续的内存空间，连续，所以二分查找的使用局限性之一。 太小也建议直接遍历，没必要二分查找。 二分查找比较适合静态有序的数组数据，这限制很大，但是只要适合的时候，性能就会很好。

我觉得二分法的循环终止条件还有每一步的high，low的变化，return什么也没啥规律可言，就具体问题具体分析，自己举个栗子分析以下，基本就差不多了 .^-.

• 放个基本框架：

int binarySearch(int[] nums, int target) {
    int left = 0, right = ...;

    while(...) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            ...
        } else if (nums[mid] < target) {
            left = ...
        } else if (nums[mid] > target) {
            right = ...
        }
    }
    return ...;
}

说起二分法，今天在图书馆有个同学过扫描机器的时候警报响了，关键他好像是个跑腿小哥，怀里抱了一摞书！他就那么一次一本过机器康康是哪一本的问题，我当时真想上去说：孩子，二分法啊！一次抱一半试啊！！！！（这个事情成功让我觉得知识好像进脑子里哈哈哈哈哈哈！！！！）

旋转数组问题的进阶

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]
注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

给你一个可能存在重复元素值的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的最小元素

区别就是可能存在重复元素；

其实就是我之前说到的那几个需要注意的地方的变化，举个栗子就好了.^-.

public int findMin(int[] nums) {
        int low = 0,high = nums.length-1;
        while(low<high){
            int mid=low+(high-low)/2;
            if(nums[mid]>nums[high]){
                low=mid+1;
            }else if(nums[mid]==nums[high]){
                high=high-1;
            }else{
                high=mid;
            }
        }
        return nums[low];
    }

---

知识点——运行时间为对数的算法

欧几里得算法

也叫辗转相除法，用于求最大公约数。原理如下：

两个整数的最大公约数等于其中较小数和两数的差的最大公约数。例如，252 和 105 的最大公约数是 21；因为 252 − 105 = 21 × (12 − 5) = 147 ，所以 147 和 105 的最大公约数也是 21。

在这个过程中，较大的数缩小了，所以继续进行同样的计算可以不断缩小这两个数直至其中一个变成零。

这时，所剩下的还没有变成零的数就是两数的最大公约数。

将上面的较大的数缩小的过程中往往使用的是 MOD 操作。

MOD，是一个 数学运算符号-----求余运算符。

例如 a mod b = c，表明 a 除以 b 余数为 c 。 在整数的除法中，只有能整除与不能整除两种情况，所以当不能整除时，就会产生余数。

我们借助于 MOD 使用 辗转相除法的概念来求数字 1112和数字 695的最大公约数。将最大的公约数设置为 n，当然虽然一开始对于每个整数是不知道可以分段成多少个 n 的，但是，可以知道 1112 和 695 都是最大公约数 n 的倍数。通过 mod 操作，不停的找余数。最后两个数是倍数关系，可以整除，余数为 0 ，结束了操作。

 public static long gcd(long m ,long n){
        while (n!=0){
            long rem = m%n;
            m=n;
            n=rem;
        }
        return m;
    }

折半查找

public static <AnyType extends Comparable<? super AnyType>>
    int binarySearch(AnyType[] a, AnyType x){
        int low = 0,high = a.length-1;
        while (low<=high){
            int mid = (low+high)/2;
            if(a[mid].compareTo(x)<0)
                low = mid +1;
            else if (a[mid].compareTo(x)>0)
                high=mid-1;
            else
                return mid;//Found
        }
        return -1;//Not Found
    }

快速的幂运算

public static long pow(long x,int n){
        if(n==0)
            return 1;
        if(n==1)
            return x;
        if (n%2==0)
            return pow(x*x,n/2);
        else
            return pow(x*x,n/2)*x;
    }
    public static void main(String[] args){

        System.out.println(pow(2,10));
    }

---

今日推歌

------《小宇》

总有些惊奇的际遇
比方说当我遇见你
你那双温柔剔透的眼睛
出现在我梦里
我的爱就像一片云
在你的天空无处停
多渴望化成阵阵的小雨
滋润你心中的土地