0
点赞
收藏
分享

微信扫一扫

基于 STM32F407 的串口 IAP

boom莎卡拉卡 10-01 22:36 阅读 2

(1) 二分查找

链接
二分查找需要序列是有序的,否则二分查找会失效。原理就是如果找的值比mid小,那么[mid,R]的内容就不需要再查找了,反之如果大于mid位置的值,则在[L,mid]内的值也不需要再查找。同时将L/R的值进行修改。注意循环结束的条件为L<=R。

public int search (int[] nums, int target) {
        // write code here
        if(nums.length==0 || nums.length==1&&nums[0]!=target){
            return -1;
        }
        int L=0, R=nums.length;
        while(L<=R){
            int mid=(L+R)/2;
            if(nums[mid]==target){
                return mid;
            }else if(nums[mid]<target){
                L=mid+1;
            }else{
                R=mid-1;
            }
        }

        return -1;
    }

(2)寻找峰值

链接
最普通的方法就是O(n),即从头到尾遍历,找到山峰就返回。

public int findPeakElement (int[] nums) {
        // write code here
        if(nums.length==1){
            return 0;
        }
        int i;
        for(i=0; i<nums.length; i++){
            if(i==0 && nums[i]>nums[i+1]){
                break;
            }else if(i==nums.length-1 && nums[i]>nums[i-1]){
                break;
            }else if(i>0 && nums[i]>nums[i-1] && nums[i]>nums[i+1]){
                break;
            }
        }
       return i;
    }

但如果使用二分查找的方法,就会更快,即O(logN)。当然,我们需要证明一下正确性:

  • 如果 nums[mid] 大于 nums[mid + 1],则在 mid 左侧(包括 mid)必定存在一个峰值。这是因为如果 nums[mid] 是一个下降点,那么在左侧必定存在一个局部最大值。
    在这里插入图片描述
    例如上图,mid大于mid+1的位置,那么右侧是可能没有峰值的。但左侧必定存在峰值。要么就是mid为峰值,要么就是mid-1更大,而就需要比较mid-2。(有一点递归的意思),而我们的设定是nums[-1] = nums[n] = −∞,因此左侧必定出现峰值。
  • 如果 nums[mid] 小于 nums[mid + 1],则在 mid 右侧(不包括 mid)必定存在一个峰值。这是因为如果 nums[mid] 是一个上升点,那么在右侧必定存在一个局部最大值。
    正确性可以得到了,那么我们就可以写代码,用二分查找的思路:
public int findPeakElement (int[] nums) {
        // write code here
        int left = 0;
        int right = nums.length - 1;

        while (left < right) {
            int mid = (right + left) / 2;

            if (nums[mid] > nums[mid + 1]) {
                // 峰值在左边
                right = mid;
            } else {
                // 峰值在右边
                left = mid + 1;
            }
        }

        return left;
    }

注意,一定会存在峰值,因此不需要我们特殊去判断是否为峰值,结束循环返回结果即可,这样可以让代码非常整洁。注意,和二分查找不一样,我们更新right不能为mid-1,否则可能找不到峰值。如下所示:
在这里插入图片描述

(3) 数组中的逆序对

链接
最简单的方法自然就是遍历,但这样的时间复杂度会很大,肯定不是优选。
我们可以用归并排序的思路。
假设我们有以下未排序的数组:

[8, 4, 2, 1]

我们想要计算这个数组中的逆序对的数量。逆序对是指数组中的两个数字,如果它们的原始位置是i和j,且i < j但A[i] > A[j],那么它们就构成一个逆序对。

让我们使用归并排序的过程来计算逆序对:

  • 第一步:分解

将数组分解为更小的数组:

[8, 4] [2, 1]

继续分解:

[8] [4] [2] [1]
  • 第二步:合并并计算逆序对

现在我们开始合并这些数组,并在合并过程中计算逆序对。

合并 [8] 和 [4]:

比较 8 和 4,发现 8 > 4,因此它们构成一个逆序对。我们将逆序对的数量增加 1,得到 1。
合并后的数组是 [4, 8]。
合并 [2] 和 [1]:

比较 2 和 1,发现 2 > 1,因此它们构成一个逆序对。我们将逆序对的数量增加 1,得到 2。
合并后的数组是 [1, 2]。
现在我们有 [4, 8] 和 [1, 2] 两个已排序的数组,接下来合并这两个数组:

比较 4 和 1、4 和 2,逆序数加2。
比较 8 和 1、8 和 2,逆序数夹2.因此最终逆序数为6.
最终合并后的数组是 [1, 2, 4, 8]。

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
     *
     *
     * @param nums int整型一维数组
     * @return int整型
     */private static final int MOD = 1000000007;

    public int InversePairs(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int[] copy = new int[nums.length];
        System.arraycopy(nums, 0, copy, 0, nums.length);
        return (int) mergeSort(nums, copy, 0, nums.length - 1);
    }

    private long mergeSort(int[] nums, int[] copy, int start, int end) {
        if (start >= end) {
            return 0;
        }
        int mid = start + (end - start) / 2;
        long left = mergeSort(copy, nums, start, mid) % MOD;
        long right = mergeSort(copy, nums, mid + 1, end) % MOD;
        int i = mid, j = end;
        int copyIndex = end;
        long count = 0;
        while (i >= start && j > mid) {
            if (nums[i] > nums[j]) {
                count += j - mid;
                copy[copyIndex--] = nums[i--];
                if (count >= MOD) {
                    count %= MOD;
                }
            } else {
                copy[copyIndex--] = nums[j--];
            }
        }
        while (i >= start) {
            copy[copyIndex--] = nums[i--];
        }
        while (j > mid) {
            copy[copyIndex--] = nums[j--];
        }
        for (i = start; i <= end; i++) {
            nums[i] = copy[i];
        }
        return (left + right + count) % MOD;
    }

}

(4) 旋转数组的最小数字

链接

我们可以把数组分为两部分,如图所示:
在这里插入图片描述
旋转数组的特点这两个子数组也是非递减的,这也就可以推断出,mid的值可能大于最右端的值,也可以小于(先不讨论等于)。

  • 如果大于最右端的值,则意味着现在的mid指向的位置在第一个子数组中
  • 如果小于最右端的值,则意味着现在的mid指向的位置在第二个子数组中。
    如果是第一种情况,则需要移动left,这样就可以逼近最小值。如果是第二种情况,就移动right,这样可以逼近最小值。
    如果出现相同元素,例如:
22212

这样是无法确定怎么移动的,我们可以将right左移。

public int minNumberInRotateArray (int[] nums) {
        // write code here
        int left = 0, right = nums.length - 1, mid = 0;
        while (left <= right) {
            mid = (left + right) / 2;
            if (nums[mid] > nums[right]) {
                left = mid + 1;
            } else if (nums[mid] < nums[right]) {
                right = mid;
            } else {
                // 当 nums[mid] 和 nums[right] 相等时,无法确定最小值的位置
                // 将右指针左移一位
                right--;
            }
        }
        return nums[mid];
    }

(5) 比较版本号

链接
可以用双指针,在while里比较每两个.之间值的大小。每次都循环直到达到最大长度或者遇到.,然后计算出两个.中间值的大小,并且进行比较。如果一个版本已经遍历完但另一个还没有,也可以继续循环,这就相当于遍历完的版本号后面多出的0,因为我们的tmp设置都为0,所以不影响比较。

version1:2.0.0.1
version2:2

比如这个用例,在version2遍历完后仍可以继续执行whileversion1中间的两个0在计算时得到的tmp1都为0,这与tmp2相等,因此相当于version2也为2.0.0.0

public int compare (String version1, String version2) {
        // write code here
        int len1=version1.length(), len2=version2.length();
        int i=0, j=0;

        while(i<len1 || j<len2){
            long tmp1=0;
            while(i<len1 && version1.charAt(i)!='.'){
                tmp1= tmp1*10 + (version1.charAt(i)-'0');
                i++;
            }
            
            long tmp2=0;
            while(j<len2 && version2.charAt(j)!='.'){
                tmp2= tmp2*10 + (version2.charAt(j)-'0');
                j++;
            }
            i++;j++; // 跳过'.'
            if(tmp1!=tmp2){
                return tmp1<tmp2? -1: 1;
            }

        }

        return 0;
    }
举报
0 条评论