『力扣和笔试算法』LeetCode:1.两数之和！

最新推荐文章于 2024-03-20 19:42:37 发布

AI大模型前沿研究

最新推荐文章于 2024-03-20 19:42:37 发布

阅读量281

点赞数

分类专栏：力扣和笔试算法文章标签： Leetcode 数据结构算法 c++

引用请附上作者博客链接https://zhangkaifang.blog.csdn.net/，谢谢理解！

本文链接：https://blog.csdn.net/abc13526222160/article/details/107759258

版权

力扣和笔试算法专栏收录该内容

11 篇文章 5 订阅

订阅专栏

LeetCode:1.两数之和！

1. 题目描述

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

示例:

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

2. 算法实现

2.1. 暴力解法

暴力算法时间复杂度 $O(n^2)$ ，空间复杂度 $O (1)$

#include <iostream>
#include <vector>
using namespace std;

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

int main()
{
    vector<int> nums{2, 7, 11, 5};
    vector<int> ans;
    Solution sol;
    ans = sol.twoSum(nums, 9);
    cout << ans[0] << ", " << ans[1] << endl;
    system("pause");
    return 0;
}

运行结果

0, 1
请按任意键继续. . .

2.2. 排序+双指针法

这里先将数组排序好 $O (n l o g n)$ ，再利用双指针法遍历一遍 $O (n)$ 得到结果。为了保存下标信息另开了一个数组时间复杂度 $O (n l o g n)$ ，空间复杂度 $O (n)$ 。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class Solution
{
public:
    vector<int> twoSum(vector<int> &nums, int target)
    {
        vector<int> ans;
        vector<int> temp;
        temp = nums;
        int n = temp.size();
        sort(temp.begin(), temp.end()); //默认升序排序；
        int i = 0, j = n - 1;           //连个指针；
        while (i < j)
        {
            if (temp[i] + temp[j] > target)
                j--;
            else if (temp[i] + temp[j] < target)
                i++;
            else
                break; //相等情况。
        }

        if (i < j) //表示找到target
        {
            for (int k = 0; k < n; k++)
            {
                if (i < n && nums[k] == temp[i])
                {
                    ans.push_back(k);
                    i = n;
                }
                else if (j < n && nums[k] == temp[j])
                {
                    ans.push_back(k);
                    j = n;
                }
                if (i == n && j == n)
                {
                    return ans;
                }
            }
        }
        return ans; //表示没有找到target
    }
};

int main()
{
    vector<int> nums{2, 7, 11, 5};
    vector<int> ans;
    Solution sol;
    ans = sol.twoSum(nums, 9);
    cout << ans[0] << ", " << ans[1] << endl;
    system("pause");
    return 0;
}

2.3. hash法

利用undered_map数组构造映射，遍历nums[i]时，看target-nums[i]是否存在hash表中即可时间复杂度 $O (n)$ ，空间复杂度 $O (n)$ 。

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;

class Solution
{
public:
    vector<int> twoSum(vector<int> &nums, int target)
    {
        unordered_map<int, int> myhash;
        vector<int> ans;
        /*首先所有的数据哈希映射表*/
        for (int i = 0; i < nums.size(); i++)
        {
            myhash[nums[i]] = i;
        }

        cout<<myhash[100]<<endl;  //输出为0，不存在；
        for (int i = 0; i < nums.size(); i++)
        {   /* 在这里判断如果存在target-nums[i]对应的值并且这个值不是自己 */
            /* 映射关系 key->value, key:target-nums[i], value:myhash[target-nums[i]] */
            if (myhash[target - nums[i]] && (myhash[target - nums[i]] != i))
            {
                ans.push_back(i);
                ans.push_back(myhash[target-nums[i]]);
                return ans;
            }
        }
        return ans;
    }
};

int main()
{
    vector<int> nums{2, 7, 11, 5};
    vector<int> ans;
    Solution sol;
    ans = sol.twoSum(nums, 9);
    cout << ans[0] << ", " << ans[1] << endl;
    system("pause");
    return 0;
}