【大数据开发阶段三】算法刷题【持续更新】

【数组】

第1题

题目【66.加一】：

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

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

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

【示例】：

输入：digits = [1,2,3]

输出：[1,2,4]

解释：输入数组表示数字 123。

链接：https://leetcode.cn/problems/plus-one

初步思路：将数组转换为数字，并对这个数字加一，然后将数字转换为数组。

实现：

class Solution {
    public int[] plusOne(int[] digits) {
        long a = 0; //记录的是每次循环后的数组代表的数值
        int b = 0;  //记录数组中的每个值要乘以10的多少次方
        for(int i = digits.length; i > 0 ; i--){       //倒着遍历数组
            a += digits[i-1] * (long) Math.pow(10, b); //想当与最后一个数字是个位，倒数第二个是十位
            b += 1;
            
        }
        a = a + 1; //对算出的数字+1
       
        Long num = Long.valueOf(a);// 输入的数字
        String str = num.toString();// 转化为字符串
        char[] charArray = str.toCharArray();// 新建一个数组用来保存num每一位的数字
        int[] intArray = new int[charArray.length];
        for (int i = 0; i < charArray.length; i++) {
            // 遍历charArray将每一位数字添加如intArray
            intArray[i] = Character.getNumericValue(charArray[i]);
        }
		
    return intArray;
    }
}

缺点：当数组长度很长时，所算出来的数值精度会丢失，未通过测试

正确思路：

class Solution {
    public int[] plusOne(int[] digits) {
        int len = digits.length;//记录数组长度
       
        for(int i = len-1;i >= 0;i--){ //从后往前遍历
            if(digits[i] == 9){        //判断是否为9
                digits[i] = 0;         //如果是9，将其变为0
            }else {
                digits[i] += 1;        //如果不是9，对其+1
                return digits;         //直接返回
            }
        }
        digits = new int[len + 1];//如果循环结束而且还没有返回，那么说明元素都是9，那就新建一个数组，长度比原来多1
        digits[0] = 1;                 //对第一个值赋值为1
        return digits;                    
        
    }
}

 

---

第2题

题目【485.最大连续1的个数】：

给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。

示例 1：

输入：nums = [1,1,0,1,1,1]
输出：3
解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.
示例 2:

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

链接：https://leetcode.cn/problems/max-consecutive-ones

初步思路：我一开始是按照最大连续相同数字进行思考的，这样虽然通用性更强，但是针对本题来说不是最优解。具体来讲是用双指针，第一个指正从0的位置开始循环，第二个指针在第一个的后面，如果第一个指针的数和第二个指针的一样，那就计数，保持第一个指针不变，第二个指针接着往下走，直到两个指针所指的数字不同，那么就移动第一个指针到下一个位置，第二个指针移动到第一个指针后面的位置，

 实现：

public int findMaxConsecutiveOnes(int[] nums) {
        int max = 0; //用来存放最大连续的个数
        int t = 0;   //
        for(int i = 0; i < nums.length; i++){
            int count = 0;
            int j = i;
            while(j < nums.length - 1 && nums[j] == nums[j+1] && nums[j] == 1) {
                count++;
                j++;
            }
            if (count > max){
                max = count;
            }
            i = j;
            if (nums[i] ==1){
                t=1;
            }
        }
        if (max == 0){
            return 0+t;
        }else{
            return max+t;
        }

    }

---

第3题

题目【11.最大连续1的个数】：

给定一个长度为 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。

【示例2:】

输入：height = [1,1]
输出：1

链接：https://leetcode.cn/problems/container-with-most-water

 思路一：暴力解法，把所有的面积枚举出来，找出最大值

public int maxArea(int[] height) {
        int max = 0;
        for(int i = 0;i < height.length;i++){
            for(int j = i+1; j < height.length;j++){
                int area = (j - i) * Math.min(height[i],height[j]);
                if (area > max){
                    max = area;
                }
            }

        }
        return max;
    }

思路二：利用双指针，从两头向内移动，每次移动较小的那个值，直到两个指针相遇 

//双指针
    public int maxArea(int[] height) {
        int num = height.length;
        int i = 0, j = num - 1; //定义头尾指针的下标
        int max = 0;            //用来存放最大值
        while( i < j ){         //两头循环
            int area = (j - i) * Math.min(height[i],height[j]);  //计算面积
            if (area > max){     //如果面积比最大值大就替换最大值
                max = area;
            }
            if(height[i] < height[j]){   //如果左边的比右边的低，就向右移动左边的
                i++;
            }else if(height[i] > height[j]){  //反之向左移动右边的
                j--;
            }else{                          //如果都相等那就都移动
                i++;
                j--;
            }
        }
        return max;

    }

第4题

题目【88.合并两个有序数组】：

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

【示例】

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

链接：https://leetcode.cn/problems/merge-sorted-array

思路：另外创建一个数组，用两个指针分别指向两个数组，挨个判断大小，小的放进数组中，用了左神视频中的merge方法 

public void merge(int[] nums1, int m, int[] nums2, int n) {
       int[] temp = new int[nums1.length];
       int i = 0; //第一个数组的下标
       int j = 0; //第二个数组的下标
       int k = 0; //新数组的下标
       while(i < m && j < n){
           temp[k++] = nums1[i] <= nums2[j] ? nums1[i++] : nums2[j++]; //当第一个数组的值小于第二个数组值时，将其放进新数组中，然后指针右移，反之放第二个指针所指的值
       }

        //当第二个数组先放完，那么第一个数组后面的值都比其他的大，直接放在最后面
       while(i < m){        
           temp[k++] = nums1[i++];
       }
        //同理
       while(j < n){
           temp[k++] = nums2[j++];
       }

        //复制数组带第一个数组
       for(int s = 0;s<temp.length;s++){
           nums1[s] = temp[s];
       }
        
    }

 

矩阵：

1.旋转图像（力扣48）

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

 

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]