LeetCode#1 - 两数之和详解

LeetCode#1 - 两数之和

题目描述

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

你可以按任意顺序返回答案。

题目分析

1. 题目要求是在一个整型数组中寻找到两个值相加为目标值，返回两个数的下标。
2. 题目要求元素元素不能使用两次，即nums[0]+nums[0] == target 不可以
3. 题目提示只会存在一个有效答案，所以在程序中寻找到满足要求的数据可以直接返回
4. 容易想到的是用枚举的方法，用两层嵌套循环，测试两数之和。
5. 枚举法，时间复杂度为O(n2)，空间复杂度是O(1)，因为运用了两层循环。并不好，我们通常的思路是用空间换时间。下面需要优化算法
6. 消耗时间的部分就是用到了线性查找，逐个比对，导致了时间复杂度的提高。我们要用其他方法代替。
7. 本质就是固定一个值，去后面剩余的数组元素中寻找另一个满足要求(target - x)的值，暴力解法用了线性查找。
8. 其实在遍历的同时，可以记录一些信息，以省去一次循环，这些信息就是已经遍历过的数值和对应的下标，可以借助查找表实现。查找表有两个常用的实现：哈希表和平衡二叉树。（引用自力扣官方题解）
9. 考虑二分查找，二分查找的思路是将数组处理为有序序列，但是还要返回原数组的对应元素的下标，这就需要开辟空间来保存原下标，空间复杂度是O(n)，排序的时间复杂度是O(nlogn)，最坏情况下再进行n-1次的二分查找，时间复杂度是O(nlogn)，总而言之，空间复杂度是O(n),时间复杂度为O(nlogn)，这并不是最好的优化方法。
10. 最后考虑哈希查找，将数组元素和下标数据全部放入哈希表中，然后固定第一个值来查找哈希表中满足要求的值，而且记住元素不能使用两次，所以要进行一个判断。
11. 对哈希查找再次进行优化如果将数组元素开始全部放入哈希表再查找会使用两次循环，我们可以将其优化为一次循环。就是循环遍历数组，如果哈希表中存在满足要求的值就返回，没有就将一组值装入哈希表。

暴力解法

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

var twoSum = function (nums, target) {
    for (var i = 0; i < nums.length - 1; i++) {
        for (var j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] === target)
                return [i, j];
        }
    }
    return [];
};

int *twoSum(int *nums, int numsSize, int target, int *returnSize)
{
    *returnSize = 2;
    int *result = 0;
    int i, j;
    for (i = 0; i < numsSize - 1; i++)
    {
        for (j = i + 1; j < numsSize; j++)
        {
            if (nums[i] + nums[j] == target)
            {
                result = (int *)malloc(sizeof(int) * 2);
                result[0] = i;
                result[1] = j;
                return result;
            }
        }
    }
    return result;
}

哈希表

// #include<unordered_map>
class Solution
{
public:
    vector<int> twoSum(vector<int> &nums, int target)
    {
        unordered_map<int, int> hashtable;
        for (int i = 0; i < nums.size(); i++)
        {
            auto it = hashtable.find(target - nums[i]);
            if (it != hashtable.end())
            {
                return {it->second, i};
            }
            hashtable.insert(nums[i],i);
        }
        return {};
    }
};

typedef struct hashTable *pHashTable;
struct hashTable
{
    int key;
    int val;
    pHashTable next;
};

pHashTable find(pHashTable table, int ikey)
{
    pHashTable n = (pHashTable)malloc(sizeof(struct hashTable));
    n = table;
    while (n)
    {
        if (n->key == ikey)
            return n;
        n = n->next;
    }
    return NULL;
}

void insert(pHashTable table, int ikey, int ival)
{
    pHashTable n = (pHashTable)malloc(sizeof(struct hashTable));
    n = table;
    pHashTable tmp = (pHashTable)malloc(sizeof(struct hashTable));
    tmp->key = ikey;
    tmp->val = ival;
    tmp->next = NULL;
    while (n->next)
    {
        n = n->next;
    }
    n->next = tmp;
}

int *twoSum(int *nums, int numsSize, int target, int *returnSize)
{
    pHashTable hashtable;
    hashtable = malloc(sizeof(struct hashTable));
    hashtable->next = NULL;
    insert(hashtable, nums[0], 0);
    for (int i = 1; i < numsSize; i++)
    {
        pHashTable it = find(hashtable, target - nums[i]);
        if (it != NULL)
        {
            int *ret = malloc(sizeof(int) * 2);
            ret[0] = it->val;
            ret[1] = i;
            *returnSize = 2;
            return ret;
        }
        insert(hashtable, nums[i], i);
    }
    *returnSize = 0;
    return NULL;
}

题目来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/two-sum