Leetcode（经典题）day1

删除有序数组中的重复项||

和之前的删除有序数组中的重复项|相似，这里是要求最多出现两次，所以多加一个变量来记录出现次数即可，整体上还是使用双指针，比较容易解出。

public int removeDuplicates(int[] nums) {
        int p1=0,p2=1,n=1;
        while (p2<nums.length){
            if (nums[p1]==nums[p2]){
                n++;
                if(n>2){
                    p2++;
                    continue;
                }
            }else {
                n=1;
            }
            nums[++p1]=nums[p2++];
        }
        return p1+1;
    }

多数元素

169. 多数元素 - 力扣（LeetCode）

使用投票法：

原理：找一个变量p记录，遇到不一样的就p--，一样就p++；因为题中说要返回的结果他的数量是大于[n/2]的，所以无论过程中怎么++或者--，到最后都会剩下至少一个要返回的数。

public int majorityElement(int[] nums) {
        int res=0;
        int tp=0;
        for(int i=0;i<nums.length;i++){
            if(tp==0){
                res=nums[i];
            }
            if(nums[i]==res){
                tp++;
            }else{
                tp--;
            }
        }
        return res;
    }

轮转数组

189. 轮转数组 - 力扣（LeetCode）

第一步：先将数组整体翻转

第二步：再翻转前k个元素

第三步：再反转剩下的n-k个元素

    public static void rotate(int[] nums, int k) {
        if(k>nums.length){
            k=k%nums.length;
        }
        fanzhuan(nums,0,nums.length-1);
        fanzhuan(nums,0,k-1);
        fanzhuan(nums,k,nums.length-1);
    }
    public static void fanzhuan(int[] nums, int l, int r){
        while(l<r){
            int temp = nums[l];
            nums[l++] = nums[r];
            nums[r--] = temp;
        }
    }

买卖股票的最佳时机

121. 买卖股票的最佳时机 - 力扣（LeetCode）

遵循低点买入，高点卖出，所以我认为的关键是找到最低点，然后依次遍历他后面的点找出"最高点"就行了

    public int maxProfit(int[] prices) {
        int n = prices.length;
        int max = 0;
        int min = 100009;
        for (int i = 0; i < n; i++) {
            if(prices[i]<min){
                min = prices[i];
            }else if(prices[i]-min>max){
                max = prices[i]-min;
            }
        }
        return max;
    }

买卖股票的最佳时机||

122. 买卖股票的最佳时机 II - 力扣（LeetCode）

使用贪心，只考虑本天买入和下一天卖出是否能赚，只要能赚（x[i+1]-x[i]>0）则将所赚计入。

    public int maxProfit(int[] prices) {
        int n = prices.length;
        int max = 0;
        for (int i = 0; i < n-1; i++) {
            max+=prices[i+1]-prices[i]>0?prices[i+1]-prices[i]:0;
        }
        return max;
    }

跳跃游戏

55. 跳跃游戏 - 力扣（LeetCode）

找一个变量max来记录当前能到达的最远距离，遍历数组的每个元素x[i]，max<i则意味着到达不了，返回false，如果max>i就进行后续操作，重新计算max的值（重新计算能到到达的最远距离），计算方式就是当前坐标位置加该位置能走几步（x[i]+i），与当前max比较取最大，然后再与数组长度比较，max>=length就返回true。

    public boolean canJump(int[] nums) {
        int max = 0;
        for(int i = 0;i < nums.length;i++){
            if(i<=max){
                max = (nums[i]+i)>max ? (nums[i]+i):max;
                if(max>=nums.length-1){
                    return true;
                }
            }
        }
        return false;
    }

跳跃游戏||

45. 跳跃游戏 II - 力扣（LeetCode）

要求返回的是最小步数，所以可以考虑使用贪心来解决，每到一个新的位置，就计算比较这个新的位置能到到达的范围中哪一个位置能到达的距离最远（也就是x[i]+i），就选择到哪一个位置，以此类推。

    public int jump(int[] nums) {
        int max = 0;
        int end = 0;
        int n = nums.length;
        int count = 0;
        for (int i = 0; i < n-1; i++) {
            max = nums[i]+i>max?nums[i]+i:max;
            if (end==i) {
                end = max;
                count++;
            }
        }
        return count;
    }