LeetCode解题随记——续更

置顶 已于 2022-10-27 15:54:17 修改
阅读量7.4k 收藏
点赞数
分类专栏： 笔记 文章标签： leetcode 算法 java
于 2021-05-29 22:48:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44653248/article/details/117392149
版权
1. 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
输入：nums = [2,7,11,15], target = 9
输出：[0,1]解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
解题思路：通过hash方式计算结果，时间复杂度O(1),首先通过第一次循环将需要比较的数字存放到map中，key为数字value为下标。然后通过第二次循环来计算结果，定义一个变量diff用来存放期望结果值与本次循环的值结果，这样一来就可以用一个简单的if判断来获取另一个数字。获取方式是map的key中是上面diff的数字且不能为本次循环的数字。最后将本次循环的数字与得到的数字下标一同存放新的数组中返回。
class Solution {
    public int[] twoSum(int[] nums, int target) {
    	//定义返回结果
        int[] result = new int[2];
        HashMap<Integer, Integer> map = new HashMap<>();
        //将所有需要比较的数字存到map，key为数字、Value为下标
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        //计算循环
        for (int j = 0; j < nums.length; j++) {
            //diff：期望计算结果-本次循环数字
            int diff = target - nums[j];
            //在map中找到结果差，并且不为同一数字
            if (map.containsKey(diff) && map.get(diff) != j) {
                result[0] = j;
                //将本次结果差下标一同存放返回结果中
                result[1] = map.get(diff);
                return result;
            }
        }
        return result;
    }
}
2. 给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。
输入：n = 1
输出：true
解释：20 = 1
解题思路1：二分查找法，首先x的范围可以确定在0-n之间的数字，定义头、中间值、尾三个，先拿中间值计算2的幂次方结果，如果大于n则说明该值得范围在头-中间值中，如果小于n则说明该值得范围在中间值-尾中，直到计算结果等于n返回true，如果所有数字计算结束都没有与n相等的，则说明n不是2的幂次方。
解题思路2：位运算，参考下图
n-1和n在二进制表示后，所有的位数都一样，除了最后边的1和之后的所有位。
由此得出 1 & 1 = 1,0 & 0 = 0，1 & 0 = 0，0 & 1 = 0，也就是如果n为2的幂次方，
那么n & n -1 == 0
在这里插入图片描述
//二分查找法
 public boolean isPowerOfTwo1(int n) {
        if (n < 1) {
            return false;
        }
        int start = 0;
        int end = n;
        while (start <= end) {
            int mid = start + (end - start) / 2;
            long result = (long) Math.pow(2, mid);
            if (result == n) {
                return true;
            }
            if (result > n) {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
        }
        return false;
    }

//位运算
 public boolean isPowerOfTwo(int n) {
        if (n < 1) return false;
        return (n & (n - 1)) / 2 == 0;
    }

3.1337. 矩阵中战斗力最弱的 K 行（简单）
给你一个大小为 m * n 的矩阵 mat，矩阵由若干军人和平民组成，分别用 1 和 0 表示。
请你返回矩阵中战斗力最弱的 k 行的索引，按从最弱到最强排序。
如果第 i 行的军人数量少于第 j 行，或者两行军人数量相同但 i 小于 j，那么我们认为第 i 行的战斗力比第 j 行弱。
军人 总是 排在一行中的靠前位置，也就是说 1 总是出现在 0 之前。
执行结果：

执行用时内存消耗执行用时分布执行消耗内存分布
2ms39.3MB72%83%
代码：
public int[] kWeakestRows(int[][] mat, int k) {
        int[] response = new int[k];
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < mat.length; i++) {
            int count = i;
            for (int j = 0; j < mat[i].length; j++) {
                int element = mat[i][j];
                if (element == 0) {
                    break;
                }
                count += 100;
            }
            list.add(count);
        }
        Collections.sort(list);
        for (int x = 0; x < k; x++) {
            response[x] = list.get(x) % 100;
        }
        return response;
    }

题解：
       嵌套for循环，外围循环大数组个数，内循环各个数组的元素。每个数组中元素为1的都加100，如3个1最后为30X，以此类推最后在取余。将list排序最后输出k个长度的数组。

4.581. 最短无序连续子数组（中等）
给你一个整数数组 nums ，你需要找出一个 连续子数组 ，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。
请你找出符合题意的 最短 子数组，并输出它的长度。
执行结果：

执行用时内存消耗执行用时分布执行消耗内存分布
8ms39MB42%97%
代码：
 public int findUnsortedSubarray(int[] nums) {
     int[] array = Arrays.copyOf(nums, nums.length);
        List<Integer> list = new ArrayList<>();
        Arrays.sort(array);
        for (int i = 0; i < nums.length; i++) {
            if (array[i] != nums[i]) {
                list.add(i);
            }
        }
        if(list.isEmpty()){
            return 0;
        }
        return list.get(list.size() - 1) - list.get(0) + 1;
    }

题解：
       复制一个数组将其排序，将两个数组进行比较，不一样的下标存在list中，最后用list最大下标减最小下标加1.

5.457. 环形数组是否存在循环
存在一个不含 0 的 环形 数组 nums ，每个 nums[i] 都表示位于下标 i 的角色应该向前或向后移动的下标个数：
如果 nums[i] 是正数，向前 移动 nums[i] 步
如果 nums[i] 是负数，向后 移动 nums[i] 步
因为数组是 环形 的，所以可以假设从最后一个元素向前移动一步会到达第一个元素，而第一个元素向后移动一步会到达最后一个元素。
数组中的 循环 由长度为 k 的下标序列 seq ：
遵循上述移动规则将导致重复下标序列 seq[0] -> seq[1] -> … -> seq[k - 1] -> seq[0] -> …
所有 nums[seq[j]] 应当不是 全正 就是 全负k > 1
如果 nums 中存在循环，返回 true ；否则，返回 false 。

执行用时内存消耗执行用时分布执行消耗内存分布
12ms39.5MB43%41%
代码：
public boolean circularArrayLoop(int[] nums) {
        int n = nums.length;
        boolean[] flag = new boolean[n];
		
        for (int i = 0; i < n; i++) {
            if (nums[i] == 0) {
                continue;
            }
            //第一步将所有元素设置为false
            for (int j = 0; j < n; j++) {
                flag[j] = false;
            }
            int mark = nums[i] > 0 ? 1 : 0;
            int p = i;
            int num = 0;
            flag[p] = true;
            while (true) {
                p = p + nums[p];
                while (p < 0) {
                    p = n + p;
                }
                while (p >= n) {
                    p = p % n;
                }
                if (flag[p] || nums[p] == 0) {
                    break;
                }
                flag[p] = true;
                int tmp = nums[p] > 0 ? 1 : 0;
                if (mark != tmp) {
                    break;
                }
                if (p != i) {
                    num++;
                }
            }
            if (num > 0 && p == i) {
                return true;
            }
        }
        return false;
    }

题解：
       定义一个同等长度布尔类型数组，将其内容初始化为false。while循环每个元素，小于0的长度+元素，大于等于0的与长度取余。一次进行比较，最后判断入参数组的步数大于0返回。

6.1337. 第 N 个泰波那契数
泰波那契序列 Tn 定义如下：
T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms35.2MB100%45%
代码：
public int tribonacci(int n) {
   if(n ==0)
    {
        return 0;
    }
        if(n ==1||n ==2)
    {
        return 1;
    }
    int num1 = 0;
    int num2 = 1;
    int num3 = 1;
    int num4 = num1 + num2 + num3;
        while(n >=3)
    {
        num4 = num1 + num2 + num3;
        num1 = num2;
        num2 = num3;
        num3 = num4;
        n--;
    }
        return num4;
    }

题解：
       根据题意，首先定义好0，1，2三个入参的返回值，为这三个数字直接返回。接下来定义num1、num2、num3、num4数字初始化。用while语句进行判断，规则为：a=b,b=c,c=d,d=a+b+c.以此类推最后返回。
如：输入数字为5，则5=2+3+4的值。输入数字为6，则6=3+4+5的值。以此类推。

7.413.等差数列划分
如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。
例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。
给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。
子数组 是数组中的一个连续序列。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms36.2MB100%42%
代码：
 public int numberOfArithmeticSlices(int[] nums) {
         if (nums.length<3) {
            return 0;
        }
        int result = 0;
        int count = 0;
        int num = nums[0] - nums[1];
       
        for (int x = 2; x < nums.length; x++) {
            if (nums[x - 1] - nums[x] == num) {
                count++;
            } else {
                num = nums[x - 1] - nums[x];
                count = 0;
            }
            result += count;
        }
        return result;
    }

题解：
首先判断nums的长度是否小于3，小于3则不符合要求直接返回。定义一个变量来存放本次等差的数值，将循环从数组第二位开始，依次对每个元素进行减法操作，并与等差变量进行比较。如果相同次数+1，如果不同将将等差变量重新赋值，并将计数器归零重新计算。

8.551. 学生出勤记录 I
给你一个字符串 s 表示一个学生的出勤记录，其中的每个字符用来标记当天的出勤情况（缺勤、迟到、到场）。记录中只含下面三种字符：
‘A’：Absent，缺勤
‘L’：Late，迟到
‘P’：Present，到场
如果学生能够 同时 满足下面两个条件，则可以获得出勤奖励：
按 总出勤 计，学生缺勤（‘A’）严格 少于两天。
学生 不会 存在 连续 3 天或 连续 3 天以上的迟到（‘L’）记录。
如果学生可以获得出勤奖励，返回 true ；否则，返回 false 。

执行用时内存消耗执行用时分布执行消耗内存分布
1ms36.3MB42%82%
代码：
 public  boolean checkRecord(String s) {
        int count = 0;
        if (s.contains("LLL")) {
            return false;
        }
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == 'A') {
                count++;
            }
        }
        return count <= 1;
    }

题解：
首先将迟到三次的情况直接排除，接下来循环所有的考勤，如果考勤等于A则天数+1，最后判断天数是否大于1。大于1则返回T反之返回F。

8.345. 反转字符串中的元音字母
给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。
元音字母包括 ‘a’、‘e’、‘i’、‘o’、‘u’，且可能以大小写两种形式出现。

执行用时内存消耗执行用时分布执行消耗内存分布
2ms39.2MB100%83%
代码：
public String reverseVowels(String s) {
        char[] result = s.toCharArray();
        int r = 0;
        int l = result.length - 1;
        char m ;
        while (r < l) {
            if (isCheck(result[r])) {
                if (isCheck(result[l])) {
                    m = result[r];
                    result[r] = result[l];
                    result[l] = m;
                    r++;
                    l--;
                } else {
                    l--;
                }
            } else {
                if (isCheck(result[l])) {
                    r++;
                } else {
                    r++;
                    l--;
                }
            }

        }
        return new String(result);
    }

    private boolean isCheck (char str) {
        return str == 'a' || str == 'o' || str == 'e' || str == 'i' || str == 'u' || str == 'A' ||
                str == 'O' || str == 'E' || str == 'I' || str == 'U';

    }

题解：
首先提示用char来运算速度较快，本题采用char[]方式进行检查。可以确定的是有四种组合情况，分别是：是是、非非、是非、非是。先定义左指针和右指针，分别用if判断四种情况，是是则左+右-并两个位置互换，非非则左+右-，是非则右-，非是则左+。

9.541. 反转字符串 II
给定一个字符串 s 和一个整数 k，从字符串开头算起，每 2k 个字符反转前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

执行用时内存消耗执行用时分布执行消耗内存分布
1ms38.6MB93%34%
代码：
public String reverseStr(String s, int k) {
        StringBuilder ss = new StringBuilder();
        int i = 0;
        boolean b = true;
        while(i < s.length()){
            if(i + k < s.length()){
                String s1 =  s.substring(i,i + k);
                if(b){
                    ss.append(new StringBuilder(s1).reverse().toString());
                    b = false;
                }else{
                    ss.append(s1);
                    b = true;
                }
            }else{
                String s1 =  s.substring(i);
                if(b){
                    ss.append(new StringBuilder(s1).reverse().toString());
                    b = false;
                }else{
                    ss.append(s1);
                    b = true;
                }
            }
            i = i + k;
        }
        return ss.toString();
    }

题解：
按照k的长度截取字符串，并将字符串按照情况反转（反转后将临时变量设置为F，则下一次的k则不反转直接拼接）。

10.217. 存在重复元素
给定一个整数数组，判断是否存在重复元素。
如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

执行用时内存消耗执行用时分布执行消耗内存分布
3ms41.5MB99%89%
代码：
  public static boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return true;
            }
        }
        return false;
    }

题解：
第一，将数组sort排序，将排序后的数字进行与后面元素比较。相等则返回T，如果比较到最后依然没有相等的则返回F。

11.53. 最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

执行用时内存消耗执行用时分布执行消耗内存分布
1ms38.4MB92%38%
代码：
 public int maxSubArray(int[] nums) {
 		int count = 0;
        int result = nums[0];
        for (int num : nums) {
            if (count > 0) {
                count += num;
            } else {
                count = num;
            }
            result = Math.max(result, count);
        }
        return result;
    }

题解：
首先定义一个int变量等于数组第0个元素，考虑到数组只有一个元素的情况。定义初始化变量如变量大于0时直接加上当前遍历元素值，如果变量小于0则直接赋值替换原有变量值。目的是保证如果上一次计算结果为负数则直接舍弃之前的数值将当前的元素放到变量中。
12.1646. 获取生成数组中的最大值
给你一个整数 n 。按下述规则生成一个长度为 n + 1 的数组 nums ：
nums[0] = 0
nums[1] = 1
当 2 <= 2 * i <= n 时，nums[2 * i] = nums[i]
当 2 <= 2 * i + 1 <= n 时，nums[2 * i + 1] = nums[i] + nums[i + 1]
返回生成数组 nums 中的最大值。

执行用时内存消耗执行用时分布执行消耗内存分布
1ms38.4MB92%38%
代码：
 public int getMaximumGenerated(int n) {
		 if (n == 0 || n == 1) {
            return n;
        }
        int result = 0;
        int[] nums = new int[n + 1];
        nums[0] = 0;
        nums[1] = 1;
        int i = 1;
        while (true) {
            if (2 * i > n) {
                break;
            }
            nums[2 * i] = nums[i];
            result = Math.max(result, nums[2 * i]);
            if (2 * i + 1 > n) {
                break;
            }
            nums[2 * i + 1] = nums[i] + nums[i + 1];
            result = Math.max(result, nums[2 * i + 1]);
            i++;
        }
        return result;
    }

13.88. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

执行用时内存消耗执行用时分布执行消耗内存分布
1ms38.6MB19%29%
代码：
 public void merge(int[] nums1, int m, int[] nums2, int n) {
        int count = 0;
        for (int i = m; i<m + n;i++) {
            nums1[i] = nums2[count++];
        }
        Arrays.sort(nums1);
    }

题解：
无脑解法：将第二个数组直接追加到第一个数组中，将第一个数组进行排序。

14.1480. 一维数组的动态和
给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。
请返回 nums 的动态和。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms38.6MB100%67%
代码：
public int[] runningSum(int[] nums) {
       int l = 1;
        int[] result = new int[nums.length];
        result[0] = nums[0];
        while (l < nums.length) {
            result[l] += nums[l];
            l++;
        }
        return result;
    }

题解：
暴力解法：每个下标对应的数组都与之前的元素+=。

15.509. 斐波那契数
斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

执行用时内存消耗执行用时分布执行消耗内存分布
0ms35.2MB100%41%
代码：
 public int fib(int n) {
            if (n < 2) {
                return n;
            }
            int a;
            int b = 0;
            int result = 1;
            for (int i = 2; i <= n; ++i) {
                a = b;
                b = result;
                result = a+ b;

            }
            return result;
        }

题解：
动态规划，按照题意描述每前两个数字相加的和等于当前数字值，一次类推相加即可。

16.搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms40.2MB100%21.77%
代码：
public static int searchInsert(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] >= target) {
                return i;
            }
        }
        return nums.length;
    }

题解：
如果有大于等于target的直接返回，否则认为是最大数返回数组的length即可。

17.最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms39.4MB100%62.66%

代码：

class Solution {
    public String longestCommonPrefix(String[] strs) {
        String str = strs[0];
        for (int i = 1; i < strs.length; i++) {
            str = comp(str, strs[i]);
            if (str.length() == 0) {
                return str;
            }
        }
        return str;
    }

    public static String comp(String str, String strs) {

        int length = Math.min(str.length(), strs.length());
        int index = 0;
        for (int i = 0; i < length; i++) {
            if (str.charAt(i) != strs.charAt(i)) {
                break;
            }
            index++;
        }
        return str.substring(0, index);
    }
}

题解：
横向扫码思想：拿出第一个字符串元素，分别与后面若干字符串charAt进行比较，取出最长相等字符即可，注意的是比较时要取字符串最短的单位当做循环位。

18.旋转矩阵
给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms39.9MB100%97.66%

代码：

class Solution {
    public void rotate(int[][] matrix) {
        int[][] b = new int[matrix.length][matrix.length];
        int bbb = matrix.length - 1;
        for (int[] ints : matrix) {
            for (int i = 0; i < ints.length; i++) {
                b[i][bbb] = ints[i];
            }
            bbb--;
        }
        for (int i = 0; i < b.length; ++i) {
            for (int j = 0; j < b.length; ++j) {
                matrix[i][j] = b[i][j];
            }
        }
    }
}

题解：
比较简单，没什么特殊注意的，分析出规律正常编写即可。

18.零矩阵
编写一种算法，若M × N矩阵中某个元素为0，则将其所在的行与列清零。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms43.3MB100%15.66%

代码：

class Solution {
    public void setZeroes(int[][] matrix) {
		int m = matrix.length;
        int n = matrix[0].length;
        boolean[] row = new boolean[m];
        boolean[] col = new boolean[n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    row[i] = true;
                    col[j] = true;
                }
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (row[i] || col[j]) {
                    matrix[i][j] = 0;
                }
            }
        }
    }
}

题解：
上面的解法采用的是标记法。既循环遍历将为零的当前行与列的下标，标记为true。最后遍历将为true的部分替换为0即可。

19.翻转字符串里的单词
给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

执行用时内存消耗执行用时分布执行消耗内存分布
4ms41.2MB80.86%73.33%

代码：

class Solution {
    public String reverseWords(String s) {
        String[] s1 = s.split(" ");
        StringBuilder builder = new StringBuilder();
        int length = s1.length;
        while (length-- > 0) {
            if (!s1[length].isEmpty()) {
                if (builder.length() > 0) {
                    builder.append(" ");
                }
                builder.append(s1[length]);
            }
        }
        return builder.toString();
    }
}

题解：
该解法是利用数组反转来处理的，将给定字符串按照空格拆分，随后循环拼接到StringBuilder中输出即可。
20.实现 strStr()
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms39.6MB100.00%37.73%

代码：

class Solution {
    public int strStr(String haystack, String needle) {
            if (Boolean.TRUE.equals(haystack.contains(needle))) {
            for (int i = 0; i < haystack.length(); i++) {
                if (haystack.length() - i < needle.length()) {
                    continue;
                }
                String substring = haystack.substring(i, i + needle.length());
                if (substring.contains(needle)) {
                    return i;
                }
            }
        }

        return -1;
    }
}

题解：
①首先判断haystack是否包含needle，如不包含直接返回-1。
②循环逐个判断是否包含needle即可。
21.反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

执行用时内存消耗执行用时分布执行消耗内存分布
0ms48.3MB100.00%36.83%

代码：

class Solution {
    public void reverseString(char[] s) {
        char a;
        int head = 0;
        int tail = s.length - 1;
        while (head < tail) {
            a = s[head];
            s[head] = s[tail];
            s[tail] = a;
            head++;
            tail--;
        }
    }
}

题解：
①比较简单，双指针替换即可。
22.两数之和 II - 输入有序数组
给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。
以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。
你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。
你所设计的解决方案必须只使用常量级的额外空间。

执行用时内存消耗执行用时分布执行消耗内存分布
925ms44.1MB5.01%70.67%

代码：

class Solution {
    public int[] twoSum(int[] numbers, int target) {
		int[] result = new int[2];
        int i1 = numbers.length - 1;
        for (int i = 0; i < i1; i++) {
            for (int j = i1; j > 0; j--) {
                if (numbers[i] + numbers[j] == target) {
                    result[0] = i + 1;
                    result[1] = j + 1;
                    return result;
                }
            }
        }
        return result;
    }
}

题解：
今天任务比较多，就临时采用一下暴力解法吧。hhh
双重for循环遍历做加法，得到相等的直接返回。

� 勿忘初心 �
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2
JUSTLOVEBOY的博客
09-29 4911
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。 注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。 示例 1： 输入：nums1 = [1,2,3,0,
【数据结构】顺序表-C语言版
局部变量和全局变量
01-09 1274
线性表是n个具有相同特性的数据元素的有限序列，是一种实际中广泛使用的数据结构，常见的线性表有顺序表、链表、栈、队列、字符串。 线性表在逻辑上是线性结构，即连续的一条直线，但在物理上不一定连续，线性表在物理上存储时，通常以数组和链式结构的形式存储。 顺序表及其特点 数组缺陷：定义数组时必须制定数组大小，但是如果指定的大小 不能满足使用空间需求时，就会有问题。 顺序表含义及特点：顺序表本质是数组，是用一段物理地址连续......
Leetcode刷题:88. 合并两个有序数组(多种方法详细解读)
最新发布
2301_76886465的博客
10-28 453
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。注意：最终，合并后数组不应由函数返回，而是**存储在数组 nums1 **中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n。提取主干1.
【leetCode】——合并两个有序数组
m0_50785976的博客
09-07 1012
LeetCode算法题——合并两个有序数组（双指针的应用）
LeetCode88.合并两个数组
m0_57385165的博客
10-11 565
1.题目描述 给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。 注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示...
LeetCode解题心得——岛屿数量（python）
01-20
来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/number-of-islands 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 思路 用宽度优先搜索思想，将一个根节点（取
LeetCode刷题笔记——#14. 最长公共前缀
12-22
二、解题分析： 1、水平扫描 class Solution: def longestCommonPrefix(self, strs: List[str]) -> str: if len(strs) == 0: return '' s = strs[0] for i in range(1, len(strs)): while strs[i].find(s) != 0 : s ...
LeetCode刷题笔记——56. 合并区间
01-20
二、解题分析： 1、解析   1）先对列表进行排序   2）判断两个相邻区间是否有交集 2、代码实现 class Solution: def merge(self, intervals: List[List[int]]) -> List[List[int]]: intervals = sorted...
LeetCode刷题笔记——#66. 加一
12-22
二、解题分析： 1、有进位位   这道题其实关注点只有一个，那就是进位的问题。设置一个进位位flag，先把最后一位加1，分离出十位和个位。之后依次对前面的数调整。判断最后依次进位位是否为1，如果是就在数组头...
leetcode2-LeetCode_Python3:Leetcode算法刷题——Python3
06-29
（此处特别感谢LeetCode解题区及评论区的大佬们提供的一些优质题解！在笔记整理过程中也参考了大佬们的解题思路，如认为有所侵权，请与我联系：） 如果有发现超链接错误或网页打不开的情况及其他问题，欢迎留言~ 剑...
力扣刷题--88、合并两个有序数组
LBJ_155207的博客
10-09 355
题目： 合并两个有序数组 题号：88 难易程度：简单 题面： 给你两个按非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。 注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。 为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。num
leetCode-88: 合并两个有序数组
jiaomubai的博客
11-05 407
题目描述：两个按非递减顺序排列的整数数组nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。 示例1： 输入：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] 。 示例2： 输入：nums1 = [1], m = 1, nums2 = [], n = 0 输出：[1].
NC202 长度最小的连续子数组
weixin_44236424的博客
10-21 193
长度最小的连续数组
LeetCode151.颠倒字符串顺序题解
Brienz
03-15 751
本题所用语言为Java，采用Java内置API解题，包含测试程序。 package com.itheima.hello; import java.lang.String; // "static void main" must be defined in a public class. public class Main { public static void main(String[] args) { String s = " hello world ";
定义一个方法判断数组中的某一个数是否存在,将结果返回给调用处
northward_wind_的博客
11-15 607
判断数字在数组中是否存在 我干这件事,需要什么才能完成? 需要数组和数字 调用处是否需要继续使用结果? 需要返回值:true false
【100分】【找等值元素】
weixin_54707168的博客
02-14 406
给一个二维数组nums，对于每一个元素num[i]，找出距离最近的且值相等的元素，输出横纵坐标差值的绝对值之和，如果没有等值元素，则输出-1。找出距离最近且值相等的元素，输出横纵坐标差值的绝对值之和。如果没有等值元素，则输出-1。示例1 输入输出示例仅供调试，后台判题数据一般不包含示例。= 3，存在一个相等的值，最近的坐标为。= 5，存在两个相等的值，最近的坐标为。，存在两个相等的值，最近的坐标为。【最多等和不相交连续子序列】= 0，不存在相等的值。，我们需要对每个元素。
用二分查找法判断任意整数在任意整数数组里面是否存在，若存在就返回它在数组中的索引位置，不存在返回-1
u010637496的专栏
08-14 6322
package com.binary; /**  * description 用二分查找法判断任意整数在任意整数数组里面是否存在，若存在就返回它在数组中的索引位置，不存在返回-1  * @author zzhao  * @version 1.0.0 BinarySerch.java 2015-7-24 下午6:17:37  */ public class BinarySerch
LeetCode第178场周赛
Fighting_初心的博客
03-08 436
1365. 有多少小于当前数字的数字 给你一个数组nums，对于其中每个元素nums[i]，请你统计数组中比它小的所有数字的数目。 换而言之，对于每个nums[i]你必须计算出有效的j的数量，其中 j 满足j != i 且 nums[j] < nums[i]。 以数组形式返回答案。 示例 1： 输入：nums = [8,1,2,2,3] 输出：[4,0,1,1,3...
leetcode刷题总结——数组
qq_40319094的博客
07-05 645
1. 两数之和 给定一个整数数组 nums和一个整数目标值 target，请你在该数组中找出 和为目标值 target的那两个整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 输入：nums = [3,3], target = 6 输出：[0,1] 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回...
苏大Python复试上机：LeetCode高频题集——英语字母顺序挑战
在苏州大学的Python复试上机环节，学生可能会被要求解决一系列来自LeetCode的编程问题，以检验他们的编程能力和对Python的理解。这些题目涵盖了多个主题，包括但不限于字符串处理、数组操作、哈希表应用、数学算法、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值