算法入门-数组2

Rivieres

已于 2024-07-18 13:28:55 修改

阅读量1k

点赞数 29

分类专栏：刷题-数组类文章标签：算法数据结构 leetcode java 推荐算法启发式算法

于 2024-07-16 16:39:29 首次发布

本文链接：https://blog.csdn.net/qq_74742024/article/details/140470131

版权

刷题-数组类专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第一部分：数组

26.删除有序数组中的重复项（简单）

题目：给你一个 非严格递增排列 的数组 nums ，请你原地删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持一致。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

第一种思路：

首先我最先想到使用Set集合，因为他的无序不重复性可以实现重复元素的删除操作，但是也是因为其无序性，如果只是简单地使用HashSet集合来实现，经过运行以后发现有部分案例无法通过，如下面的案例：
输入nums =[-3,-1,0,0,0,3,3]

输出：[-1,0,-3,3]

预期结果：[-3,-1,0,3]
究其原因，就是其无序性导致的，在Java中，HashSet是无序的数据结构，因此在使用HashSet对元素去重后，元素的顺序不会保持原先数组中的顺序。理由是，在HashSet或HashMap等集合类中，元素的存储并不是简单地按元素的大小来排列的，而是通过哈希函数将元素映射到对应的存储位置。

因此，虽然从数值本身来说-1比-3要大，但是在哈希集合中具体存储的位置并不一定按这个大小顺序排列。哈希集合是根据哈希函数的计算结果来确定元素的存储位置的，而不是根据元素大小来排序的。

但是，在此基础上，可以使用LInkedHashSet，他可以实现按照插入时的顺序存储元素。LinkedHashSet底层使用LinkedHashMap实现，它通过双向链表维护元素的插入顺序，因此可以保持元素的插入顺序，不会改变元素在集合中的顺序。

当然，这种思路不费脑力，但是方案确实不太好（复杂度太高了）~~

class Solution {
    public int removeDuplicates(int[] nums) {
        LinkedHashSet<Integer> mySet = new LinkedHashSet<>();
        for(int num : nums)
            mySet.add(num);
        int i = 0;
        for(Integer num : mySet)
            nums[i++]=num;
        return mySet.size();
    }
}

第二种思路：

想到昨天的数组题目，那么可不可以使用指针完成呢，简单作一下草图，发现完全可以行得通，不仅只需要遍历一遍数组，还不需要创建额外的空间。

首先创建两个指针，一个指针p1用来指向存储保留的元素，一个指针p2用来遍历数组中的每个元素。

初始时，两个指针p1,p2都指向下标为0的数组元素，然后在循环中,p2不断后移，然后有两种情况：

如果p2指向的元素与p1指向的元素相同，则不进行任何操作，然后p2继续后移

如果p2指向的元素与p1指向的元素不同，则p1后移一个单位，然后将现在p2指向的元素赋值给p1，然后p2再后移

之后重复循环，因为p2总是在p1之后（只有初始时相同），所以循环的条件是p2小于数组的长度。

PS：昨天学到的今天就想到还用上了还是很高兴的🤩 最后运行结果也是很惊喜击败了百分百（虽然题目很简单，但也增加了继续学习的信心）

class Solution {
    public int removeDuplicates(int[] nums) {
       int p1 = 0;
       int p2 = 0;
       int size = 1;
       while(p2 < nums.length){
            if(nums[p1]==nums[p2]){
                p2++;
            }else{
                nums[++p1]=nums[p2++];
                size++;
            }
       }
       return size;
    }
}

66.加一（简单）

题目：给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1：

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

看了官解和其他大佬的解答豁然开朗，自己每次碰到这种题目总是会牵扯到字符串的操作里，这次也是如此，在字符串里折腾了半天也只是通过了部分案例（太丑陋了😭）。所以说数组里的操作别想得太复杂，别动不动就朝字符串的方向操作，狠狠学到。

第一种思路：观察数组末尾数字9的情况（逢九进一），有三种情况，

末尾最后一位不是9，则数组末尾数字直接加1返回数组

末尾有若干个9，则找到从后往前第一个不为9的数字加1，后面元素全置为0，然后返回数组

数组全为9，则直接创建一个新数组（大小为原数组长度加一），首元素为1，其余元素为0

class Solution {
    public int[] plusOne(int[] digits) {
        if(digits[digits.length - 1]!=9){
            digits[digits.length - 1]++;
            return digits;
        }else{
            digits[digits.length-1]=0;
            for(int i = digits.length - 1 - 1; i >= 0; i--){
                if(digits[i]==9){
                    digits[i]=0;
                    continue;
                }else{
                    digits[i]++;
                    return digits;
                }                
            }
            int[] d = new int[digits.length+1];
            d[0]=1;
            System.arraycopy(digits,0,d,1,digits.length);
            return d;
        }
    }
}

第二种思路（很妙,击败百分百）：

同样是逆序遍历数组，将最后一个元素加1，然后判断这一位上的数字是否小于10，

小于10 的话就直接返回数组，得出结果

等于10 的话就把这一位的数字置为0，然后继续循环

当循环结束后，意味着数组的第一位也置为0了，也就是说，数组原来就全部是9，所以直接创建一个新数组（大小为原数组长度加一），首元素为1，其余元素为0，最后返回数组，得出结果.

class Solution {
    public int[] plusOne(int[] digits) {
        for(int i = digits.length - 1; i >= 0; i--){
            digits[i]++;
            if(digits[i] < 10)
                return digits;
            else
                digits[i] = 0;
        }
        int[] d = new int[digits.length+1];
        d[0]=1;
        System.arraycopy(digits,0,d,1,digits.length);
        return d;
    }
}

11.盛最多水的容器（中等）

题目：给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

第一种思路：

真是把双指针学狠了，首先就想到用双指针操作进行双层循环，思路很简单，就是单纯地把所有盛水‘面积’计算出来，然后取最大值返回，当然看到双层循环（虽然可以做出来）就知道时间复杂度挺高的，结果不出所料超出时间限制，思路很简单就不详细介绍了

class Solution {
    public static int maxArea(int[] height) {
        int p = 0;
        int max = 0;
        int l = 0;
        int w = 0;
        for(;p < height.length;p++){
            int q = p+1;
            while(q < height.length){
                l = q - p;
                w = Math.min(height[p],height[q++]);
                if(max < l * w)
                    max = l * w;
            }
        }
        return max;
    }
}

第二种思路：

来自一个精选解答，同样采用双指针，确实厉害，不过美中不足的是没有击败百分百🤩

两个指针（左指针设为q,右指针设为p)分别指向数组的首位元素，盛水’面积‘为：(p-q)*Math.min(height[q],height[p]) ,无论长板还是短板，向中间收缩后，底边长度都会减一，这时考虑两种情况：

当向内移动的是短板，底边长度减一，但是这时短板的高度可能会变大，所以盛水的’面积‘可能会变大

当向内移动的是长板，底边长度减一，但是这时短板的高度不会改变，所以盛水的’面积’一定会变小

所以每次循环时比较两个板子的长度，将短板向内移动，同时计算盛水’面积‘并更新最大面积，到两个指针相遇时，得出盛最多水的容器。

可能有人有疑问，这样会不会遗漏某些情况导致错过最大值？

但是需要注意的是，因为上述两种情况，我们在循环中只向中间移动短板，这个时候短板就改变了，拿上面的例子来说，初始时q = 0, p = 8,这时通过比较短板是q=1指向的元素height[q]=1，所以将q=0向中间移动即q=1，这时因为q = 1 ,height[q] = 8 ,短边就变成了p=8, height[p] = 7,

所以这种思路的长板和短板会根据移动而发生改变，因此不会遗漏任何情况。

class Solution {
    public static int maxArea(int[] height) {
       int q=0,p=height.length-1;
       int max = 0;
       int temp = 0;
       while(q < p){
            temp = (p-q) * Math.min(height[q],height[p]);
            if(max < temp)
                max = temp;
            if(height[q]<height[p]){
                q++;
            }else{ 
                p--;
            }
       }
       return max;
    }
}

继续坚持~