LeetCode刷题 - (01)两数之和

题目描述

给定一个整数数组nums和一个目标值target,请你在该数组中找出和为目标值的那两个整数,并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是,你不能重复利用这个数组中同样的元素。

示例:


给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法一 暴力解法

解题思路

最容易想到的就是暴力法,使用两个遍历,查找两数之和是否为target。流程如下:

  1. 使用i来遍历数组每个元素
  2. i的每一个循环中,使用ji + 1开始遍历
  3. 判断ij对应的值的和是否为target

代码实现

func twoSum(nums []int, target int) []int {
    for i := 0; i < len(nums); i ++ {
        for j := i + 1; j < len(nums); j ++{
            if nums[i] + nums[j] == target{
                return []int{i,j}
            }
        }
    }
    return []int{}
}

复杂度分析

  • 时间复杂度: O(n^2)。一共有两次循环,每次循环的事件复杂度是O(n)。总的复杂度为O(n^2)。
  • 空间复杂度: O(1)。

解法二 哈希表解法

解题思路

该解法中会借助一个哈希表。在遍历数组时,会将当前元素添加到哈希表中。并且会检查哈希表中是否已经存在当前元素所对应的目标元素。如果存在就返回。

代码实现

func twoSum2(nums []int, target int) []int {
    m := make(map[int]int)
    for i := 0; i < len(nums); i ++ {
        if index, exists := m[target - nums[i]]; exists {
            return []int{i,index}
        }
        m[nums[i]] = i
    }
    return []int{}
}

复杂度分析

  • 时间复杂度:O(n)。我们只遍历了一次数组。
  • 空间复杂度:O(n)。使用了哈希表,需要额外的空间。取决于哈希表中存储的元素数量,该表最多需要存储O(n)个元素。

原文地址:https://www.cnblogs.com/leiwei/p/11443656.html

时间: 2024-12-07 01:30:13

LeetCode刷题 - (01)两数之和的相关文章

LeetCode刷题8——两数之和

一.要求 二.背景 数组: 数组是在程序设计中,为了处理方便,把具有相同类型的若干元素按有序的形式组织起来的一种形式.抽象地讲,数组即是有限个类型相同的元素的有序序列.若将此序列命名,那么这个名称即为数组名.组成数组的各个变量称为数组的分量,也称为数组的元素.而用于区分数组的各个元素的数字编号则被称为下标,若为此定义一个变量,即为下标变量 三.思路 (1)挨个找两数之和等于目标值,并找对应两个数的索引,当两个数相等的时候 修改代码后运行成功 (2)进阶版:如果是三个数之和呢 原文地址:https

LeetCode刷题-001两数之和

给定一个整数数列,找出其中和为特定值的那两个数.你可以假设每个输入都只会有一种答案,同样的元素不能被重用.示例:给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1] 1 int* twoSum(int* nums, int numsSize, int target) 2 { 3 int i,j; 4 int* p=(int*)malloc(sizeof(int)*2); 5 for(i=0;

leetcode刷题2:两数相加add_two_numbers

题目:两数相加 (难度:中等) 给定两个非空链表来表示两个非负整数.位数按照逆序方式存储,它们的每个节点只存储单个数字. 将两数相加返回一个新的链表. 你可以假设除了数字 0 之外,这两个数字都不会以零开头. 示例: 输入:(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出:7 -> 0 -> 8 原因:342 + 465 = 807 思路: 本题的思路很简单,按照小学数学中学习的加法原理从末尾到首位,对每一位对齐相加即可. 技巧在于如何处理不同长度的数字

Leetcode(1)两数之和

Leetcode(1)两数之和 [题目表述]: 给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标.你可以假设每种输入只会对应一个答案.但是,你不能重复利用这个数组中同样的元素. 第一种方法:暴力 执行用时:5352 ms: 内存消耗:12.9MB 效果:非常差 class Solution(object): def twoSum(self, nums, target): """ :type nums:

LeetCode Golang实现 1. 两数之和

1. 两数之和 给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标. 你可以假设每种输入只会对应一个答案.但是,你不能重复利用这个数组中同样的元素. 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 方法一: 暴力法: leetCode 给出运行时间 60ms func twoSum(nums []int

LeetCode题解001:两数之和

两数之和 题目 给定一个整数数组 nums?和一个目标值 target,请你在该数组中找出和为目标值的那?两个?整数,并返回他们的数组下标 你可以假设每种输入只会对应一个答案.但是,你不能重复利用这个数组中同样的元素 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] Java: 方法一:暴力法 暴力法很简单,就是用两遍循环的方式遍历nums class Solution {

Leetcode第1题:两数之和

给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的 两个 整数.你可以假设每种输入只会对应一个答案.但是,你不能重复利用这个数组中同样的元素.示例:给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1] Python: nums = [2, 7, 11, 15, 29] target = 17 # print(nums[0]) def calcOrder(n

[leetcode题解]01两数之和

给定一个整数数组 nums?和一个目标值 target,请你在该数组中找出和为目标值的那?两个?整数,并返回他们的数组下标. 你可以假设每种输入只会对应一个答案.但是,你不能重复利用这个数组中同样的元素. 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 分析 关键字:数组.查找.下标. 由于数组是无序的,查找必须要遍历,不能用二分查找,时间复杂度一般最小为O(n). 暴力解法:遍历

leetcode 01两数之和

给定一个整数数组和一个目标值,找出数组中和为目标值的两个数. 你可以假设每个输入只对应一种答案,且同样的元素不能被重复利用. 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1] 暴力法: class Solution {public:    vector<int> twoSum(vector<int>& nums, int target) {