leetcode1 两数之和

长沙有肥鱼

已于 2023-11-08 14:43:31 修改

阅读量98

点赞数 1

分类专栏： leetcode100 文章标签： python

于 2023-10-20 13:46:36 首次发布

本文链接：https://blog.csdn.net/weixin_53660567/article/details/132814694

版权

leetcode100 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

🚀🏆🍀✨👇👇👇🌴🎄🎈🚀🔥🔥🔥🌟🍀🎉🎉🎉🎉

python3暴力法不完整代码：🌟🌟🍀🎉🎉🎉

class Solution:
    def twoSum(self, nums, target):
        """
        在给定的整数数组中寻找两个数的索引，使它们的和等于目标值。

        :param nums: 整数数组
        :param target: 目标值
        :return: 包含两个数的索引的列表
        """
        # 遍历数组
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):  # # 内层循环从 i+1 开始，避免重复计算
                if nums[i] + nums[j] == target:  # 判断是否满足条件
                    return [i, j]  # 如果满足条件，返回索引列表
                return []  # 如果没有找到匹配的数值，则返回一个空列表

python3暴力法完整代码：

# -*- coding: utf-8 -*-
# @Time    : 2023/9/10 14:24
# @Author  : 长沙有肥鱼
# @FileName: 两数之和暴力法.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

class Solution:
    def twoSum(self, nums, target):
        """
        在给定的整数数组中寻找两个数的索引，使它们的和等于目标值。

        :param nums: 整数数组
        :param target: 目标值
        :return: 包含两个数的索引的列表
        """
        # 遍历数组
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):  # # 内层循环从 i+1 开始，避免重复计算
                if nums[i] + nums[j] == target:  # 判断是否满足条件
                    return [i, j]  # 如果满足条件，返回索引列表
                return []  # 如果没有找到匹配的数值，则返回一个空列表
# 测试用例
nums = [2, 7, 11, 15]  # 数组
target = 9  # 目标值

solution = Solution()  # 实例化Solution类
result = solution.twoSum(nums, target)  # 调用 twoSum 函数,传入 nums 和 target,将返回结果存储在 result 中
print(f"暴力法得到的结果为:", result)  # 打印结果

python3哈希表不完整代码：

class Solution:
    # def twoSum(self, nums: [int], target: [int]) -> [int]:
    def twoSum(self, nums, target):
        hashtable = dict()  # 创建哈希表用于存储数值与索引的对应关系
        for i, num in enumerate(nums):  # 遍历整个数组
            complement = target - num  # 计算需要匹配的另一个数值
            if complement in hashtable:  # 检查是否在哈希表中存在这个数值
                return [hashtable[complement], i]  # 返回找到两个数值的索引
            hashtable[nums[i]] = i  # 将当前数值和其索引添加到哈希表中
        return []  # 如果没找到符合条件的组合,则返回一个空数组

python3哈希表完整代码：

# -*- coding: utf-8 -*-
# @Time    : 2023/9/10 11:41
# @Author  : 长沙有肥鱼
# @FileName: 两数之和哈希表.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

class Solution:
    # def twoSum(self, nums: [int], target: [int]) -> [int]:
    def twoSum(self, nums, target):
        hashtable = dict()  # 创建哈希表用于存储数值与索引的对应关系
        for i, num in enumerate(nums):  # 遍历整个数组
            complement = target - num  # 计算需要匹配的另一个数值
            if complement in hashtable:  # 检查是否在哈希表中存在这个数值
                return [hashtable[complement], i]  # 返回找到两个数值的索引
            hashtable[nums[i]] = i  # 将当前数值和其索引添加到哈希表中
        return []  # 如果没找到符合条件的组合,则返回一个空数组

# 示例用法
nums = [2, 7, 11, 15]  # 数组
target = 9  # 目标值

solution = Solution()  # 实例化Solution类
result = solution.twoSum(nums, target)  # 调用twoSum函数
print(f"哈希表得到的结果为:", result)  # 输出 [0, 1]

c++暴力法不完整代码：

// 定义一个名为 Solution 的类
class Solution{
public:
    // 定义名为 twoSum 的函数,接受一个整数向量 nums 和一个整数 target,并返回一个整数向量
    std::vector<int> twoSum(vector<int> &nums, int target){
        //遍历数组
        for(int i = 0; i < nums.size();++i){
            for(int j = i + 1;j < nums.size();++j){
                if(nums[i] + nums[j] == target ){
                    return {i, j};//返回符合条件的两个数的索引
                }
            }
        }
        return {};// 如果找不到符合条件的组合,则返回一个空数组
    }
};

c++暴力法完整代码：

// -*- coding: utf-8 -*-
// @Time    : 2023/9/11 18:26
// @Author  : 长沙有肥鱼
// @FileName: 两数之和暴力法.cpp
// @Software: CLion
// @Blog    ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

#include<iostream> // 输入输出流库
#include<vector>// 向量容器库

using namespace std;
// 定义一个名为 Solution 的类
class Solution{
public:
    // 定义名为 twoSum 的函数,接受一个整数向量 nums 和一个整数 target,并返回一个整数向量
    std::vector<int> twoSum(vector<int> &nums, int target){
        //遍历数组
        for(int i = 0; i < nums.size();++i){
            for(int j = i + 1;j < nums.size();++j){
                if(nums[i] + nums[j] == target ){
                    return {i, j};//返回符合条件的两个数的索引
                }
            }
        }
        return {};// 如果找不到符合条件的组合,则返回一个空数组
    }
};

int main(){
    std::vector<int> nums = {2,7,11,15};// 定义一个整数向量 nums,并初始化
    int target = 9;//定义目标数值,并初始化

    Solution solution;//实例化Solution类
    std::vector<int> result = solution.twoSum(nums, target);// 调用 twoSum 函数,传入 nums 和 target,将返回结果存储在 result 中

    if (result.size() == 2) {
        cout << "find two digital index:" << result[0] << " and " << result[1] << endl; // 输出找到的两个数字的索引
    }
    else {
        cout << "not find two digital index!" << endl;// 输出未找到符合条件的组合
    }
}

c++哈希表不完整代码：

// 定义一个名为 Solution 的类
class Solution{
public:// 定义一个名为 Solution 的类
    // 定义名为 twoSum 的函数,接受一个整数向量 nums 和一个整数 target,并返回一个整数向量
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;// 使用哈希表存储数值与索引的对应关系
        //遍历数组
        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];//计算需要匹配的另一个数值
            // 检查是否存在与当前元素相加等于目标值的元素
            if(hashtable.find(complement) != hashtable.end()){
                return {hashtable[complement], i};// 返回找到的匹配数值的索引和当前元素的索引
            }

            // 将当前元素及其索引添加到哈希表
            hashtable[nums[i]] = i;//将当前数值和索引存入哈希表中
        }

        return {}; // 如果找不到符合条件的组合,则返回一个空数组
    }
};

// 定义一个名为 Solution 的类
class Solution{
public:// 定义一个名为 Solution 的类
    // 定义名为 twoSum 的函数,接受一个整数向量 nums 和一个整数 target,并返回一个整数向量
    std::vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map<int, int> hashtable;// 使用哈希表存储数值与索引的对应关系
        std::vector<int> result;
        //遍历数组
        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];//计算需要匹配的另一个数值

            // 检查是否存在与当前元素相加等于目标值的元素
        if (hashtable.find(complement) != hashtable.end()) {
            result.push_back(hashtable[complement]);
            result.push_back(i);
            return result;
        }
            if(hashtable.find(complement) != hashtable.end()){
                return {hashtable[complement], i};// 返回找到的匹配数值的索引和当前元素的索引
            }

            // 将当前元素及其索引添加到哈希表
            hashtable[nums[i]] = i;//将当前数值和索引存入哈希表中
        }

        return result; // 如果找不到符合条件的组合,则返回一个空数组
    }
};

c++哈希表完整代码：

// -*- coding: utf-8 -*-
// @Time    : 2023/9/11 18:22
// @Author  : 长沙有肥鱼
// @FileName: 两数之和哈希表.cpp
// @Software: CLion
// @Blog    ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

#include <iostream>               // 输入输出流库
#include <vector>                 // 向量容器库
#include <unordered_map>          // 无序映射容器库（哈希表）

using namespace std;
// 定义一个名为 Solution 的类
class Solution{
public:// 定义一个名为 Solution 的类
    // 定义名为 twoSum 的函数,接受一个整数向量 nums 和一个整数 target,并返回一个整数向量
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;// 使用哈希表存储数值与索引的对应关系
//    vector<int> result;
        //遍历数组
        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];//计算需要匹配的另一个数值
            // 检查是否存在与当前元素相加等于目标值的元素
            if(hashtable.find(complement) != hashtable.end()){
                return {hashtable[complement], i};// 返回找到的匹配数值的索引和当前元素的索引
            }

            // 将当前元素及其索引添加到哈希表
            hashtable[nums[i]] = i;//将当前数值和索引存入哈希表中
        }

        return {}; // 如果找不到符合条件的组合,则返回一个空数组
    }
};


int main() {
    vector<int> nums = { 2, 7, 11, 15 };// 定义一个整数向量 nums,并初始化
    int target = 9;//定义目标数值,并初始化

    Solution solution;//实例化Solution类
    vector<int> result = solution.twoSum(nums, target);// 调用 twoSum 函数,传入 nums 和 target,将返回结果存储在 result 中
    for (int num : result) {
        std::cout << num << " ";
    }

    return 0; // 返回 0，表示程序正常结束
}

// -*- coding: utf-8 -*-
// @Time    : 2023/9/11 18:22
// @Author  : 长沙有肥鱼
// @FileName: 两数之和哈希表.cpp
// @Software: CLion
// @Blog    ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343

#include <iostream>               // 输入输出流库
#include <vector>                 // 向量容器库
#include <unordered_map>          // 无序映射容器库（哈希表）

using namespace std;
// 定义一个名为 Solution 的类
class Solution{
public:// 定义一个名为 Solution 的类
    // 定义名为 twoSum 的函数,接受一个整数向量 nums 和一个整数 target,并返回一个整数向量
    std::vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map<int, int> hashtable;// 使用哈希表存储数值与索引的对应关系
        std::vector<int> result;
        //遍历数组
        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];//计算需要匹配的另一个数值

            // 检查是否存在与当前元素相加等于目标值的元素
        if (hashtable.find(complement) != hashtable.end()) {
            result.push_back(hashtable[complement]);
            result.push_back(i);
            return result;
        }
            if(hashtable.find(complement) != hashtable.end()){
                return {hashtable[complement], i};// 返回找到的匹配数值的索引和当前元素的索引
            }

            // 将当前元素及其索引添加到哈希表
            hashtable[nums[i]] = i;//将当前数值和索引存入哈希表中
        }

        return result; // 如果找不到符合条件的组合,则返回一个空数组
    }
};


int main() {
    std::vector<int> nums = { 2, 7, 11, 15 };// 定义一个整数向量 nums,并初始化
    int target = 9;//定义目标数值,并初始化

    Solution solution;//实例化Solution类
    std::vector<int> result = solution.twoSum(nums, target);// 调用 twoSum 函数,传入 nums 和 target,将返回结果存储在 result 中
    // 如果返回结果result的大小为2
    if (result.size() == 2) {
        cout << "find two digital index:" << result[0] << " and " << result[1] << endl; // 输出找到的两个数字的索引
    }
    else {
        cout << "not find two digital index!" << endl;// 输出未找到符合条件的组合
    }

    return 0; // 返回 0，表示程序正常结束
}

Java暴力法不完整代码：

class Solution {
    // 定义名为 twoSum 的方法,用暴力法遍历所有可能的组合
    public static int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {  // 遍历数组
            for (int j = i + 1; j < nums.length; j++) {  // 遍历数组剩余部分
                if (nums[i] + nums[j] == target) {  // 找到符合条件的组合
                    // 返回找到的匹配数值的索引
                    return new int[]{i, j};
                }
            }
        }
        // 如果找不到符合条件的组合，返回一个空数组
        return new int[]{};
    }
}

Java暴力法完整代码：

/**
 * @Time : 2023/9/11 19:19
 * @Author : 长沙有肥鱼
 * @FileName: twoSumBruteforce.java
 * @Software: IntelliJ IDEA
 * @Blog : https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343 19
 **/
class twoSumBruteforce {
    // 定义名为 twoSum 的方法,用暴力法遍历所有可能的组合
    public static int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {  // 遍历数组
            for (int j = i + 1; j < nums.length; j++) {  // 遍历数组剩余部分
                if (nums[i] + nums[j] == target) {  // 找到符合条件的组合
                    // 返回找到的匹配数值的索引
                    return new int[]{i, j};
                }
            }
        }
        // 如果找不到符合条件的组合，返回一个空数组
        return new int[]{};
    }

    public static void main(String[] args) {
        int[] nums = {2, 7, 11, 15};  // 定义一个整数数组 nums
        int target = 9;  // 定义目标数值

        int[] result = twoSum(nums, target);  // 调用 twoSum 方法,传入 nums 和 target

        if (result.length == 2) {  // 判断是否找到了符合条件的组合
            System.out.println("找到的两个数的索引为:" + result[0] + "和" + result[1]);  // 输出找到的两个数字的索引
        }
        else {
            System.out.println("未找到两个数的索引!");  // 输出未找到符合条件的组合
        }
    }
}

Java哈希表不完整代码：

class Solution {
    public  int[] twoSum(int[] nums,int target){
        HashMap<Integer, Integer> map = new HashMap<>();//创建一个哈希表,用于存储数字和其对应的索引
        for(int i = 0;i < nums.length;i++){
            int complement = target - nums[i];//计算需要匹配的另一个数值
            //检查是否存在与当前元素相加等于目标值的元素
            if(map.containsKey(complement)){
                return new int[]{map.get(complement),i};//返回找到的匹配数值的索引和当前元素的索引
            }
            map.put(nums[i],i);//将当前数值和索引存入哈希表中
        }
        return new int[]{};
    }
}

Java哈希表完整代码：

/**
 * @Time : 2023/9/11 21:28
 * @Author : 长沙有肥鱼
 * @FileName: twoSumHashtable.java
 * @Software: IntelliJ IDEA
 * @Blog ：https://blog.csdn.net/weixin_53660567?spm=1010.2135.3001.5343 28
 **/
import java.util.HashMap;//导入哈希表库

public class twoSumHashtable {
    public static int[] twoSum(int[] nums,int target){
        HashMap<Integer, Integer> map = new HashMap<>();//创建一个哈希表,用于存储数字和其对应的索引
        for(int i = 0;i < nums.length;i++){
            int complement = target - nums[i];//计算需要匹配的另一个数值
            //检查是否存在与当前元素相加等于目标值的元素
            if(map.containsKey(complement)){
                return new int[]{map.get(complement),i};//返回找到的匹配数值的索引和当前元素的索引
            }
            map.put(nums[i],i);//将当前数值和索引存入哈希表中
        }
        return new int[]{};
    }
    public static void main(String[] args){
        int[] nums = {2,7,11,15};// 定义一个整数数组 nums
        int target = 9;// 定义目标数值
        int[] result = twoSum(nums,target);// 调用 twoSum 方法,传入 nums 和 target

        if(result.length == 2){
            System.out.println("哈希表法找到的两个数的索引为:" + result[0] + "和" + result[1]); // 输出找到的两个数字的索引
        }
        else{
            System.out.println("未找到符合条件的两个数!");// 输出未找到符合条件的组合
        }
    }
}