leetcode Two Sum-Java 和Python 的写法

news2024/12/24 9:02:44

我想这题是正要开始写LeetCode 的人，大部分的人的第一题吧，这题是个基本题算在easy 的题型，看到题目直接就会想到使用双回圈的写法，不过双回圈时间复杂度只有达到 O(N^2) 不那么理想，如果比较资深的工程师会用HashMap 做处理，这时时间复杂度可以达到N(1)，这篇有Java 和Python 的写法。

给定一个整数数组 nums 和一个整数 target，返回两个数字的索引，使它们加起来等于 nums。

您可能会假设每个输入只有一个解决方案，并且您可能不会两次使用相同的元素。您可以按任何顺序返回答案。

给定一个整数阵列nums和一个整数结果target，阵列中会有两个元素加起来等于整数结果target，回传这两个元素的位置。

你可能假设每个输入只会对应一个答案，而且你不能使用同样的元素两次你可以回传任何顺序的答案。

题目限制

同样的元素不能使用两次

2 <= nums.length <= 104

109 <= nums[i] <= 109

109 <= target <= 109

范例：

    Input: nums = [2,7,11,15], target = 9
    Output: [0,1]
    Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Input: nums = [3,2,4], target = 6
    Output: [1,2]

Input: nums = [3,3], target = 6
    Output: [0,1]

思路&笔记

使用暴力的解法：

双回圈回圈1 取得第一个索引，回圈2 取得第二个索引

但回圈2 的循环起始需要做个i+1，目的是元素不要重复到

当回圈2 的索引都循环完后，回圈1 的索引会换到下一个索引，以此类推

直到两个索引的值加起来，等于目标整数target，就把当下的索引回传出来

JAVA 初阶实现

使用暴力解法：双回圈

类解决方案{
        public int[] twoSum(int[] nums, int target) {
            对于 (int i=0; i < nums.length; i++){
                for (int j = i+1; j < nums.length; j++){ // 元素不要重新到
                    如果（nums[i] + nums[j] == 目标）{
                        返回新的 int[] {i, j}; // 回传索引
                    }
                }
            }
            返回新的 int[] {}; // 当找不到符合条件的组合时，返回一个空的数组列表
        }
    }

JAVA 进阶实现

笔者还在学习中，参考了讨论区里网友的解法。

这里有使用HashMap 存资料。

遍历时用target 减掉当下索引的值，可以得出另一个整数。(这个就是我们要相加起来的另一个整数，没有的话代表不是两数的合)

因第一次判断Map 本来就是空的一定不成功，所以把已判断过的元素跟索引存进Map 里。(这里要颠倒存，因为之后判断时要取索引，索引放在值的地方)

之后遍历第二次时，判断 .containsKey() 搜寻Map 里有无key，这时true 进入判断式

.get()取值(刚颠倒存入的索引) → 0 i 则是当下的索引→ 1

最后把两个索引存入 new int[] 阵列中[0, 1]

import java.util.HashMap;
    import java.util.Map;
    
    class Solution {
        public int[] twoSum(int[] nums, int target) {
            Map<Integer, Integer> numToIndex = new HashMap<>();
            for (int i = 0; i < nums.length; i++) {
                // 判断键是否存在 Map
                if (numToIndex.containsKey(target - nums[i])) { // 目标整数 - 索引 1 的值
                    // 回传两个索引
                    return new int[] {numToIndex.get(target - nums[i]), i}; // numToIndex 里的"值"是索引,当前 i 是索引
                }
                // 把前面的资料添加进 Map 
                numToIndex.put(nums[i], i);  // {2,0} (注意这边是颠倒的存进去)
            }
            return new int[] 0; // 仍未找到符合要求的元素，则返回一个空的 int[] 阵列
        }
    }

Python 初阶实现

使用了和Java 一样的逻辑执行，换成Python 的写法。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)): # 索引从第2个开始
                if i != j and nums[i] + nums[j] == target: # 索引不要重复且索引值相加
                    return [i, j]
		return []

Python 进阶实现

笔者还在学习中，参考了讨论区里网友的解法。

使用了和Java 一样的逻辑执行，换成Python 的写法。

class Solution:
    
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        numToIndex = {} # 字典
        for i in range(len(nums)):
            # 判断键是否存在 Map
            if target - nums[i] in numToIndex: # 目标整数 - 索引 1 的值
                return [numToIndex[target - nums[i]], i] 
            # 把前面的资料添加进字典
            numToIndex[nums[i]] = i # 键 nums[i] = 值 i
        return []