leetcode笔记刷题（一）1.两数之和 -哈希表

之前从没有在leetcode上面刷过题，就来刷一刷，补充一下平时知识点的不足。

第一道题：

 

自己本地测试代码：

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


/*
注：malloc 是 c 语言中的动态分配内存，result=(int*)malloc(sizeof(int)*2)； 
malloc 函数返回的是 void\* 型，所以要强制类型转换成 int，在前面加上 (int *)，
才能给整型赋值，后面 (sizeof(int)*2) 的意思是分配两个 int 大小的空间；

总结：该方法简单但是时间复杂度为 O(n^2^)。空间复杂度为 O(1)O(1);运行速度慢且内存空间消耗大
*/
int* twoSum(int* nums, int numsSize, int target) {
	int i, j;
	int *result = NULL;
	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;
}


/*
暴力法
总结：该方法简单但是时间复杂度为 O(n^2^)。空间复杂度为 O(1)O(1);运行速度慢且内存空间消耗大
*/
//class Solution {
//public:
//	vector<int> twoSum(vector<int>& nums, int target) {
//		int i, j;
//		for (i = 0; i < nums.size() - 1; i++)
//		{
//			for (j = i + 1; j < nums.size(); j++)
//			{
//				if (nums[i] + nums[j] == target)
//				{
//					return{ i,j };
//				}
//			}
//		}
//		return{};
//	};
//};

/*
两遍哈希表
注：该方法用 map 实现，map 是 STL 的一个关联容器，它提供一对一
（其中第一个可以称为关键字，每个关键字只能在 map 中出现一次，第二个可称为该关键字的值）的数据处理能力
总结：该方法简单但是时间复杂度为 O(2n)。空间复杂度为 O(n)
*/
//class Solution {
//public:
//	vector<int> twoSum(vector<int>& nums, int target) {
//		map<int, int> a;//建立hash表存放数组元素
//		vector<int> b(2, -1);//存放结果
//		for (int i = 0; i < nums.size(); i++)
//			a.insert(map<int, int>::value_type(nums[i], i));
//		for (int i = 0; i < nums.size(); i++)
//		{
//			if (a.count(target - nums[i]) > 0 && (a[target - nums[i]] != i))
//				//判断是否找到目标元素且目标元素不能是本身
//			{
//				b[0] = i;
//				b[1] = a[target - nums[i]];
//				break;
//			}
//		}
//		return b;
//	};
//};

/*
一遍哈希表
注：该方法用 map 实现，map 是 STL 的一个关联容器，它提供一对一
（其中第一个可以称为关键字，每个关键字只能在 map 中出现一次，第二个可称为该关键字的值）的数据处理能力
总结：该方法简单但是时间复杂度为 O(n)。空间复杂度为 O(n) // 在leetcode上提交会报错

*/
class Solution {
public:
	vector<int> twoSum(vector<int>& nums, int target) {
		map<int, int> a;//提供一对一的hash
		vector<int> b(2, -1);//用来承载结果，初始化一个大小为2，值为-1的容器b
		for (int i = 0; i < nums.size(); i++)
		{
			if (a.count(target - nums[i]) > 0)
			{
				b[0] = a[target - nums[i]];
				b[1] = i;
				break;
			}
			a[nums[i]] = i;//反过来放入map中，用来获取结果下标
		}
		return b;
	};
};


int main()
{
	/*int nums[] = {2,7,11,15};
	int numbsize = 4;
	int target = 9;
	int* index;
	index = twoSum(nums, numbsize, target);
	if (index != NULL)
	{
		std::cout << "the indexs of two number are:" << index[0] << "," << index[1] << std::endl;
		free(index);
	}
	else
	{
		std::cout << "the target can not be achieved by two numbers add." << std::endl;
	}*/

	vector<int> nums{2,7,11,15};
	int target = 9;
	vector<int> result;
	Solution sln;
	result = sln.twoSum(nums, target);
	if (result.size() != 0)
	{
		std::cout << "the indexs of two number are: " << result[0] << "," << result[1] << std::endl;
	}
	else
	{
		std::cout << "the target can not be achieved by two numbers add." << std::endl;
	}
	/*if (result[0] != -1)
	{
		std::cout << "the indexs of two number are: " << result[0] << "," << result[1] << std::endl;
	}
	else
	{
		std::cout << "the target can not be achieved by two numbers add." << std::endl;
	}*/
	return 0;
}

主要看的是评论区的 一遍哈希与两遍哈希，其中一遍哈希更快，但是有时提交会报错，有时通过。

一遍哈希：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<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);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

两遍哈希：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement) && map.get(complement) != i) {
                return new int[] { i, map.get(complement) };
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}