2021-04-06力扣刷题

1.面试题 17.10. 主要元素

数组中占比超过一半的元素称之为主要元素。给定一个整数数组，找到它的主要元素。若没有，返回-1。

（1）法一：不需要额外存储空间，但需要先排序。

class Solution {
    public int majorityElement(int[] nums) {
        int mainNum=-1;
        if(nums.length==1){
            return nums[0];
        }
        int n=nums.length/2+1;
        Arrays.sort(nums,0,nums.length);
        int max=0;   //纪录最大频率
        int maxNum=-1;  //记录最大频率对应的数值
        int record=0;
        for(int i=0;i<nums.length;i++){
            if(i==0){
                record=1;
            }
            else{
                if(nums[i]==nums[i-1]){
                    record++;
                    if(i==nums.length-1&&record>max){
                        max=record;
                        maxNum=nums[i];      
                    }
                }
                else{
                    if(record>max){
                        max=record;
                        maxNum=nums[i-1];
                    }
                    record=1;
                }
            }
        }
        if(max>=n){
            mainNum=maxNum;
        }
        return mainNum;
    }
}

2.找出数组游戏的赢家

给你一个由 不同 整数组成的整数数组 arr 和一个整数 k 。

每回合游戏都在数组的前两个元素（即 arr[0] 和 arr[1] ）之间进行。比较 arr[0] 与 arr[1] 的大小，较大的整数将会取得这一回合的胜利并保留在位置 0 ，较小的整数移至数组的末尾。当一个整数赢得 k 个连续回合时，游戏结束，该整数就是比赛的 赢家 。

返回赢得比赛的整数。

题目数据 保证 游戏存在赢家。

(1)法一：感觉面试会死。。。

class Solution {
    public int getWinner(int[] arr, int k) {

        int count=0;  //统计当前位置0处赢得回合。
        int winnerNum=arr[0];
        List<Integer> vector=new LinkedList<>();
        int max=arr[0];
        int maxLocation=0;
        for(int i=0;i<arr.length;i++){
            vector.add(arr[i]);
            if(max<arr[i]){
                max=arr[i];
                maxLocation=i;
            }
        }
        if(k>maxLocation-1){
            return max;
        }
        int temp1,temp2,temp3;
        while(count<k){
            if(vector.get(0)<vector.get(1)){
                temp1=vector.get(0);
                temp2=vector.get(1);
                vector.remove(0);
                vector.remove(0);
                vector.add(0,temp2);
                vector.add(arr.length-1,temp1);
                winnerNum=temp2;
                count=1;
            }
            else{
                temp3=vector.get(1);
                vector.remove(1);
                vector.add(arr.length-1,temp3);
                count++;
            }
        }
        return winnerNum;
    }
}

（2）法二：大佬就是大佬

//注意：其实有点脑筋急转弯的感觉
//遍历一次如果还没找到Winner那么此时一定就是当前Winner所在处为数组最大值，不需要再走
//反之，如果一次遍历未完成时就找到了Winner那正好
//所以不管怎么样都可以控制在一次遍历下解决这个问题；
比较好的一点就是，我已经开始慢慢去试着想问题中存在的那种想法了，这题暴力走起来估计肯定玩球，但是我加了一了东西所以没完蛋但是效果也一般。

class Solution {
    public int getWinner(int[] arr, int k) {
        int winnerIndex=0;
        int winnerNum=arr[0];
        int count=0;
        int x;
        for(int i=1;i<arr.length&&count<k;i++){
            x=arr[i];
            if(winnerNum>x){
                count++;
            }
            else{
                winnerNum=x;
                count=1;
            }
        }
        return winnerNum;
    }
}

3.删除有序数组中的重复项 II

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 最多出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明：

为什么返回数值是整数，但输出的答案是数组呢？

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

示例 1：

输入：nums = [1,1,1,2,2,3]
输出：5, nums = [1,1,2,2,3]
解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。 不需要考虑数组中超出新长度后面的元素。
空间还行，但是效率不行

class Solution {
    public int removeDuplicates(int[] nums) {
        int nowLength=nums.length;
        int count=0;
        //int num=0;
        for(int i=0;i<nowLength;i++){
            if(i==0){
                count=1;
            }
            else{
                if(nums[i]==nums[i-1]){
                    count++;
                    if(count>2){
                        for(int j=i+1;j<nums.length;j++){
                            nums[j-1]=nums[j];
                        }
                        i--;
                        count--;
                        nowLength--;
                    }
                }
                else{
                    count=1;
                }
            }
        }
        return nowLength;
    }
}

（2）双指针法（永远的神）

class Solution {
    public int removeDuplicates(int[] nums) {
        //双指针法；
        int left=0;
        int count=0;
        int nowLength=nums.length;
        //i在这里就表示右指针
        for(int i=0;i<nums.length;i++){
            if(i==0){
                count=1;
            }
            else{
                if(nums[left]==nums[i]){
                    count++;
                    if(count>2){
                        count--;
                        nowLength--;
                    }
                    else{
                        left++;
                        nums[left]=nums[i];
                    }
                }
                else{
                    count=1;
                    nums[left+1]=nums[i];
                    left++;
                }
            }
        }
        return nowLength;
    }
}

（3）法三，充分利用foreach取值的特点以及数据排好序的特点，牛

class Solution {
    public int removeDuplicates(int[] nums) {
        int i=0;
        for(int n:nums){
            if(i<2||n>nums[i-2]){
                nums[i++]=n;
            }
        }
        return i;
    }
}