第一题：两数之和

gaoqiangliang

于 2023-06-11 13:54:21 发布

阅读量99

点赞数

分类专栏： LeetCode编程练习--简单题集文章标签： leetcode

本文链接：https://blog.csdn.net/congcong0509/article/details/131152629

版权

LeetCode编程练习--简单题集专栏收录该内容

1 篇文章 0 订阅

订阅专栏

题目
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
方法1：暴力破解法
算法思想：
题目给定了一个一维数组nums，有给定了一个目标值target，很容易就可以联想到nums[0] + nums[1] =? Target，如果相等，则直接返回0和1即可，如果不相等，则nums[0] + nums[2] =? Target,继续进行判断。可以从上面的伪代码看出，可以使用循环语句对数据nums进行遍历，但是仔细想来，nums[0]+nums[1]、nums[0]+nums[2]、nums[0]+nums[3]……，好像是需要使用两层的for循环！，是的，没错，猜对了。这就是暴力破解法解决这道题的核心思想了。下面是我给出的一个两层for循环的伪代码，仅仅作为参考。

for(i = 0; i < n; ++i){
           for(j = i+1; j < n; ++j){
               if(nums[i] + nums[j] == target){
                   return {i, j};
               }
           }

这是用python语言编写的，其中的n代表的是一维数组nums的长度。
注：这里先说一下，本人目前主要学习的是C++和python，因此只用这两种编程语言进行编写程序！
软件介绍：C++使用的是：Dev-C++5.5.3，python使用的是：Pycharm2022.2.2(Community Edition)
解题步骤：
Step1：定义循环变量i和j，以及数组长度n
Step2：两层for循环，第二层for循环j从i+1开始
Step3：if语句判断，若nums[i]+nums[j] == target，则返回i和j，否则继续循环
这里题目中已经给出了假设“你可以假设每种输入只会对应一个答案。”，因此不会出现输入的数据找不到相等的target，所以不需要对if语句不成立的情况进行处理。
程序代码(C++)：

class Solution{
	public:
	vector<int> twoSum(vector<int>& nums, int target){
		int n=nums.size();
		int i, j;
		for(i = 0; i < n; ++i){
			for(j = i+1; j < n; ++j){
				if(nums[i] + nums[j] == target){
					return {i, j};
				}
			}
		}
		return {};
	}

};

算法测试：
在这里插入图片描述
程序代码(Python)：

 def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    return [i, j]

算法测试：

在这里插入图片描述
算法时间空间复杂度分析：
时间复杂度：因为是两层for循环，因此时间复杂度是T(n)=O(n^2)
空间复杂度是T(n) = O(1)
T(n) = O(f(n))
T(n)表示算法的渐进复杂度，可以是时间也可以是空间复杂度，这里的O代表的是正比例关系，O(f(n))中的f(n)代表的是代码执行的次数。

方法二：哈希映射法
算法思想：
首先第一个哈希表，hash，用来存储两数之和中的第一个数，也就是被加数，而输入数组nums则当成加数，我们一开始for循环遍历nums数字，然后计算被加数target-nums[i]，接着判断一下被加数是否在哈希表中(当然，一开始创建的哈希表是一个空表，什么也没有。)，如果在则说明我们要找的被加数的下标和加数的下标此时分别是：hash.get(a),i-----这里的a就是两数之和中的被加数，否则就把加数nums[i]添加到哈希表中(把加数看作被加数)。
算法步骤：
Step1：首先定义一个哈希表
Step2：for循环，计算被加数a = target-nums[i]，判断哈希表中是否存在a，如果存在则返回下标：hash.get(a)，i，不存在转下一步。
Step3：将加数看作被加数添加到hash表中。

程序代码(C++)：

vector<int> twoSum(vector<int>& nums, int target){
    std::unordered_map<int, int> numMap;
	std::vector<int> result;

    for (int i = 0; i < nums.size(); i++) {
        int complement = target - nums[i];

        if (numMap.find(complement) != numMap.end()) {
            result.push_back(numMap[complement]);
            result.push_back(i);
            return result;
        }

        numMap[nums[i]] = i;
    }

    return result;
	
}

算法测试：
在这里插入图片描述
程序代码(Python)：

    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        map_1 = {}
        for i in range(len(nums)):
            a = target - nums[i]
            if a in map_1.keys():
                return [map_1.get(a), i]
            map_1[nums[i]] = i

算法测试：
在这里插入图片描述
算法空间时间复杂度分析：
时间复杂度：遍历一次数组，需要 O(n) 的时间复杂度，其中 n 是数组的大小。查找：对于每个元素，最坏情况下需要在哈希表中查找一次。哈希表的查找操作平均情况下具有 O(1) 的时间复杂度。因此，在最坏情况下，总共需要 O(n) 的时间复杂度。
空间复杂度：哈希表的存储：在最坏情况下，哈希表需要存储数组中的所有元素，因此需要额外的空间来存储这些元素。所以空间复杂度为 O(n)。除了输入数组和目标值外，程序使用了一个哈希表来存储元素及其索引。因此，该程序的空间复杂度为 O(n)。