Leetcode第一题--两数之和（两种解法、两种语言实现）

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

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

示例:

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

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

2.暴力解法（时间复杂度O（n*n））
暴力解法没什么好说的，两个for遍历，就是注意他是要两个不同的元素且一个元素不能重复使用，所以循环中j=i+1。

c语言实现

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize)
{
    // numsSize=sizeof(nums)/sizeof(nums[0]);
     int* ret=(int *)malloc(sizeof(int)*2);
    for(int i=0;i<numsSize;i++)
    {
        for(int j=i+1;j<numsSize;j++)
        {
            int sum=nums[i]+nums[j];
            if(sum==target)
            {
                *ret=i;
                *(ret+1)=j;
                *returnSize=2;
                return ret;
            }
        }
    }
    *returnSize=0;
    return NULL;
} 
/*
int main()
{
    int nums[]={2,7,11,15};
    int numsSize=sizeof(nums)/sizeof(nums[0]);

    int returnSize[];
    return 0;
}
*/

3.哈希表–时间复杂度O（N）

c语言实现
执行用时: 4 ms
内存消耗: 5.8 MB

这里c语言实现有点麻烦
这里没有手写哈希表，而是用了别人的头文件
#include"uthash.h"
下载链接
https://github.com/troydhanson/uthash

这里的核心思想是使用哈希表，哈希表中存放了键值对，键用来存储数组的元素，值用来存储数组的下标。在哈希表的键中查找target-nums[i]是否存在，存在则说明找到了，则返回找到的下标和i。如果没找到，就将元素的值存入键中，下标存入值中。一直遍历整个数组一定能找到结果。

#define  _CRT_SECURE_NO_WARNINGS 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "uthash.h"

//哈希解法
//*******************************************************
typedef struct Hashtable
{
    int key;
    int val;
    UT_hash_handle hh;//内部使用的hash处理句柄
}Hash;

 Hash *hashtable;

 Hash* find(int ikey)
{
    struct Hashtable* ret;
    HASH_FIND_INT(hashtable, &ikey, ret);
    return ret;
    //第一个参数users是哈希表，第二个参数是user_id的地址（一定要传递地址）。
    //最后s是输出变量。当可以在哈希表中找到相应键值时，s返回给定键的结构，当找不到时s返回NULL
}

void insert(int ikey, int ival)
{
    struct Hashtable* it = find(ikey);//检查是否已经在哈希表中了
    if (it == NULL)
    {
        //如果不在构建一个hashtable结构体
        Hash* tmp = (Hash*)malloc(sizeof(Hash));
        tmp->key = ikey;
        tmp->val = ival;
        HASH_ADD_INT(hashtable, key, tmp);///* 这里必须明确告诉插入函数，自己定义的hash结构体中键变量的名字 */
    }
    else
    {
        //如果在只需要修改值
        it->val = ival;
    }
}

int* twoSum1_c(int* nums, int numsSize, int target, int* returnSize)
{
    //先查哈希表中有没有想要的，没有就保存
    hashtable = NULL;
    for (int i=0; i < numsSize; i++)
    {  
        Hash* it = find(target-nums[i]);
        if (it != NULL)
        {
            int* ret = (int*)malloc(sizeof(int) * 2);
            ret[0] = it->val;
            ret[1] = i;
            *returnSize = 2;
            return ret;
        }
        insert(nums[i],i );
    }
    *returnSize =0;
    return NULL;
}
int main_c()
{
    
    int nums[3]={3,2,4};
    int target = 6;
    int numsSize=0;

    int a = 0;
    int* returnSize=&a;
    printf("resultsize =%d", *returnSize);
    numsSize = sizeof(nums) / sizeof(nums[0]);
    int* ret=twoSum1_c(nums,numsSize,target, returnSize);
    printf("result i =%d ,j= %d\n", ret[0], ret[1]);
    printf("resultsize =%d\n", *returnSize);
    return 0;
}
//*******************************************************

c++实现
执行用时: 8 ms
内存消耗: 9.4 MB

思路是一样的，这里实现就简单多了，用STl中的unordered_map，内部已经实现哈希表。

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

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target)//引用做函数参数
    {
        unordered_map<int, int> hashtable;
        //vector<int> ret;
       
        for (int i = 0; i < nums.size(); i++)
        {
            unordered_map<int, int>::iterator it = hashtable.find(target - nums[i]);
            //找到就返回
            if (it != hashtable.end())
            {
                
               // ret.push_back(it->second);
                //ret.push_back(i);
                return {it->second,i};//这里不定义ret直接返回好像可以省点运行时间
            }
           //没找到就将pair插入
            else//健为数组中的值，值为数组下标
            {
                hashtable.insert(make_pair(nums[i], i));
               // hashtable[nums[i]] = i;
               
            }
        }
        //return ret;
        return {};
    }
};