Leetcode题解思考

两数之和

描述

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

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

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

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

解答

首先暴力解法。

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

对数组进行两次循环,外循环是数组元素的从头遍历，每一个元素的外循环对应着

从他下一个元素开始的内循环。内循环中的操作是比较内外循环两个数字之和是否等于题目所给的target。如果与题目所给出的target相等，则返回对应的两个元素的下标。

利用hashtable

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[nums[i]] = i;
        }
        return {};
    }
};

unordered_map😄无序映射，是用来存储键值和映射值的组合。

在这里换一个思考方式，寻找两个数相加等于目标值的值，即寻找的数从一个加数变成了一个差。这里，无序映射的作用十分明显。

我们从数组第一个元素开始遍历，此时我们与我们所建立的无序映射中的元素进行比照。因为一开始无序映射中是没有元素的，所以第一次比对的时候一定是找不到结果的，于是我们将这一个不匹配的元素的值以及他在数组中的位置存储起来，因为是无序映射，因此我们将数组的值当作无序映射的键值，而将数组的位置定义为无序映射键值对应的值，因为这样，我们在以后的寻找过程中一旦发现匹配的数据，我们可以利用数组值马上找到其对应的索引值。

C语言解法

因为嵌入式大多使用c语言写，c语言写就不可避免的要去手动的造轮子，其他语言的一些使用方法别人已经封装好了，直接调用就行。这里的哈希表用c语言实现也学习了一下。半学习吧，因为也要引入对应的头文件。

文章参考

（1）首先引入头文件,定义hashtable的结构体

#include "uthash.h"

struct hashTable{
    int key;
    int val;
    UT_hash_handle hh;
};
struct hashTable* hashtable;

（2）查询接口

struct hashTable* find(int ikey){
    struct hashTable* tmp;
    HASH_FIND_INT(hashtable, &ikey, tmp);
    return tmp;
}

(3 ) 插入接口

void insert(int ikey, int ival){
    struct hashTable* it = find(ikey);
    if (NULL == it){
        struct hashTable* tmp = malloc(sizeof(struct hashTable));
        tmp->key = ikey;
        tmp->val = ival;
        HASH_ADD_INT(hashtable, key, tmp);
    }else {
        it->val = ival;
    }
}

（4）删除接口

void delete(int ikey){
    struct hashTable* tmp = NULL;
    HASH_FIND_INT(hashtable, ikey, tmp);
    if (NULL != tmp){
        HASH_DEL(hashtable, tmp);
        free(tmp);
        tmp = NULL;
    }
}

(5)清空hashtable接口

void delete_all(){
    struct hashTable *currentTable, *tmp;
    HASH_ITER(hh, hashtable, currentTable, tmp){
        HASH_DEL(hashtable, currentTable);
        free(currentTable);
        currentTable = NULL;
    } 
}

(6)统计hash table中已经存在的元素数

unsigned int elementNum;
elementNum = HASH_COUNT(hashtable);

下面是LeetCode的c语言题解

int* sum(int* arr, int arr_size, int target, int* ret_size){
    hashtable = NULL;
    for (int i = 0; i < arr_size; i++){
        struct hashTable* it = find(target - arr[i]);
        if (NULL != it){
            int* ret = malloc(sizeof(int) * 2);
            ret[0] = i, ret[1] = it->val;
            *ret_size = 2;
        }
        insert(arr[i], i);
    }
    
    *ret_size = 0;
    return NULL;
}