LeetCode高频算法面试题 - 001 - 两数之和

漫步coding 4/21/2022

题目来源于 LeetCode 上第 1 号问题：两数之和。题目难度为 Easy。

# 题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

题目难度: ★, 简单

示例:

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

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

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

# 题目解析

使用查找表来解决该问题。

设置一个 map 容器 record 用来记录元素的值与索引，然后遍历数组 nums。

每次遍历时使用临时变量 complement 用来保存目标值与当前值的差值
在此次遍历中查找 record ，查看是否有与 complement 一致的值，如果查找成功则返回查找值的索引值与当前变量的值 i
如果未找到，则在 record 保存该元素与索引值 i

# 代码实现

tips: 以下代码是使用Go代码实现的不同解法, 文章最后可以看C++、C、Java、Python实现

# 1、暴力解法

最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。

当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x。

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

执行结果:

时间复杂度：O(N^2)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
空间复杂度：O(1)。

内存方面还可以，不过运行时间偏慢, 时间复杂度太高了。

# 2、使用map方式, nums 的值进行倒排索引, 以空间换时间，时间复杂度是O(n)

func twoSum(nums []int, target int) []int {
    numsMap := make(map[int]int)

    for index, num := range nums{
        numsMap[num] = index    
    }

    for index, num := range nums {
        if preIndex, ok := numsMap[target-num];  (ok && preIndex != index) {
            return []int{preIndex, index}
        } 
        
    }
    return []int{}
}

执行结果:

时间复杂度：O(n)，我们只遍历了包含有O(n)个元素的列表两次。在表中进行的每次查找只花费 O(1)的时间。
空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 N个元素。

# 3、使用map方式, nums 的值进行倒排索引，一遍哈希表

事实证明，我们可以一次完成。在进行迭代并将元素插入到表中的同时，我们还会回过头来检查表中是否已经存在当前元素所对应的目标元素。如果它存在，那我们已经找到了对应解，并立即将其返回。

func twoSum(nums []int, target int) []int {
    numsMap := make(map[int]int)
    for index, num := range nums {
        if preIndex, ok := numsMap[target-num]; ok {
            return []int{preIndex, index}
        }
        numsMap[num] = index
    }
    return []int{}
}

执行结果:

时间复杂度：O(n)，我们只遍历了包含有O(n)个元素的列表一次。在表中进行的每次查找只花费 O(1)的时间。
空间复杂度：O(n)，所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 N个元素。

# 4、双指针游标

双指针的思路

将原数组排好序, 设置两个指针left, right
left 从0开始, right 做 len(nums) - 1 开始
当nums[left] + nums[right] < target时，我们就没有必要对所有的right0 ∈(left, right)，因为nums[left] + nums[right0] 一定是比target小的, 所以left = left + 1后重新判断
当nums[left] + nums[right] > target时，同样的，对left0 ∈(left, right)，必然有nums[left0] + nums[right] > target, 所以right = right - 1后重新判断
当nums[left] + nums[right] = target时，就是我们想要知道的两个数值了
然后利用Map将数值转换为之前的游标

func twoSum(nums []int, target int) []int {
	type Node struct{
		Value int
		Next  *Node
	}
	 // 用链表是解决数组重复问题
	numsMap := make(map[int]*Node)
	var current *Node
	for index, num := range nums{
		if _, ok := numsMap[num]; ok{
			current = numsMap[num]
			for {
				if current.Next == nil{
					current.Next = &Node{index, nil}
					break
				}

				current = current.Next
			}
		}else{
			numsMap[num] = &Node{index, nil}
		}
	}

	sort.Ints(nums)
	left := 0
	right := len(nums) - 1
	for {
		if left >= right{
			break
		}

		sum := nums[left] + nums[right]
		if sum == target{
			if nums[left] == nums[right]{
				return []int{numsMap[nums[left]].Value, numsMap[nums[left]].Next.Value}
			}else{
				return []int{numsMap[nums[left]].Value, numsMap[nums[right]].Value}
			}

		}

		if sum < target{
			left ++

		}else{
			right --
		}
	}
	return []int{}
}

执行结果:

因为要排序，时间复杂度也比较高, 需要Map存储游标，空间复杂度也比较高, 算是一个不太好的实现方式。

# 其他语言版本

# C++

// 1. Two Sum
// 时间复杂度：O(n)
// 空间复杂度：O(n)
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> record;
        for(int i = 0 ; i < nums.size() ; i ++){
       
            int complement = target - nums[i];
            if(record.find(complement) != record.end()){
                int res[] = {i, record[complement]};
                return vector<int>(res, res + 2);
            }

            record[nums[i]] = i;
        }
        return {};
    }
};

执行结果

# C

// 1. Two Sum
// 时间复杂度：O(n)
// 空间复杂度：O(n)
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int *ans=(int *)malloc(2 * sizeof(int));
    int i,j;
    bool flag=false; 
    for(i=0;i<numsSize-1;i++)
    {
        for(j=i+1;j<numsSize;j++)
        {
            if(nums[i]+nums[j] == target)
            {
                ans[0]=i;
                ans[1]=j;
                flag=true;
            }
        }
    }
    if(flag){
        *returnSize = 2;
    }
    else{
        *returnSize = 0;
    }
    return ans;
}

执行结果

# Java

// 1. Two Sum
// https://leetcode.com/problems/two-sum/description/
// 时间复杂度：O(n)
// 空间复杂度：O(n)
class Solution {
    public int[] twoSum(int[] nums, int target) {
        int l = nums.length;
        int[] ans=new int[2];
        int i,j;
        for(i=0;i<l-1;i++)
        {
            for(j=i+1;j<l;j++)
            {
                if(nums[i]+nums[j] == target)
                {
                    ans[0]=i;
                    ans[1]=j;
                }
            }
        }
        
        return ans;
        
    }
}

执行结果

# Python

# 1. Two Sum
# https://leetcode.com/problems/two-sum/description/
# 时间复杂度：O(n)
# 空间复杂度：O(n)
class Solution(object):
    def twoSum(self, nums, target):
        l = len(nums)
        print(nums)
        ans=[]
        for i in range(l-1):
            for j in range(i+1,l):
                if nums[i]+nums[j] == target:
                    ans.append(i)
                    ans.append(j)
                    print([i,j])
                    break
        return ans

执行结果

# 结语

综合来看，选择方式3比较好: 使用map方式, nums 的值进行倒排索引，一遍哈希表, Go的实现在内存方面和时间复杂度都还可以， Python相对表现就差很多。

# 几种语言运行效果对比

Go程序在内存方面表现最佳, Python在内存和运行时间表现比较其他的语言都比较差。

也欢迎关注我的公众号: 漫步coding。一起交流, 在coding的世界里漫步。

前言 0002 - 两数相加

漫步coding