题目
给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是,你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
解析
第一次做leetcode,我寻思都不给数据范围的么==!题目给出一个整型范围内的数组和一个目标数,要求找出数组内和为该数的两个单元的下标,题目保证解存在且唯一,但是不能把同一个下标的数重复用两遍,即[2, 3, 4, 15], target = 6例子下答案不会是[1, 1],但是[2, 3, 3, 15], target = 6例子下答案可以是[1, 2],体会一下。
解法一:暴力法
直接二重循环遍历原数组,找到和为target后直接返回下标。O(n2)
(刚开始刷leetcode的同道们注意了哈,和其他OJ不同的是,leetcode只需要完成给出的函数即可,不需要输入输出,但是可以写其他函数,也可以定义全局变量(不知道是否会和没给出的部分冲突),宏定义、结构体定义等等;除了返回必要的参数外,结尾一定要再return一次,也不知道为什么,但一定这样才不会出错)
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
int *result = (int*)malloc(sizeof(int) * 2);
int i, j;
for(i = 0; i < numsSize; i++) {
for(j = i + 1; j < numsSize; j++) {
if(nums[i] + nums[j] == target) {
result[0] = i;
result[1] = j;
*returnSize = 2;
return result;
//break;
}
}
}
return 0;//这里一定要再返回一次不知道为什么
}
解法二:hash
对数组做一个hash,然后遍历整个数组,对于下标i,去hash查找target - nums[i]是否在数组中。(注意hash容量10007不够,但100003是够的)
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
#define PN 100003
int hash[PN];
int hash_index[PN];
void hash_insert(int key, int index) {
int t = abs(key) % PN;
while(hash_index[t] >= 0) t = (t + 1) % PN;
hash[t] = key;
hash_index[t] = index;
}
int inhash(int key) {
int t = abs(key) % PN;
while(hash_index[t] >= 0) {
if(hash[t] == key) return hash_index[t];
else t = (t + 1) % PN;
}
return -1;
}
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
int i, j;
int *result = (int*)malloc(sizeof(int) * 2);
for(i = 0; i < PN; i++) hash_index[i] = -1;
for(i = 0; i < numsSize; i++) {
hash_insert(nums[i], i);
}
for(i = 0; i < numsSize; i++) {
int t = target - nums[i];
int index = inhash(t);
if(index >= 0 && index != i) {
result[0] = i;
result[1] = index;
*returnSize = 2;
return result;
}
}
return 0;
}
突发奇想其实hash的时候可以把数字看出字符串用字典树查找,不过速度上没啥用
(map直接搞定只是想试一试)
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
typedef struct node *Trie;
struct node {
int key;
Trie next[11];
};
Trie root;
char* convert(int number) {
char *ret = (char*)malloc(15);
char *str1 = (char*)malloc(15);
int len = 0;
int flag = 0;
if(number < 0) {
flag = 1;
}
number = abs(number);
str1[len++] = (number % 10) + '0';
number /= 10;
while(number != 0) {
str1[len++] = (number % 10) + '0';
number /= 10;
}
int i = 0, j = len - 1;
if(flag) ret[i++] = '-';
while(j >= 0) {
ret[i] = str1[j];
i++;
j--;
}
ret[i] = '\0';
return ret;
}
void trie_insert(char *name, int len, int index) {//字典树插入
Trie p = root;
int i, j;
for(i = 0; i < len; i++) {
int k;
if(name[i] == '-') k = 10;
else k = name[i] - '0';
if(p->next[k] == NULL) {
p->next[k] = (Trie)malloc(sizeof(struct node));
for(j = 0; j < 11; j++) p->next[k]->next[j] = NULL;
p->next[k]->key = -1;
}
p = p->next[k];
}
p->key = index;
}
int trie_find(char *name, int len) {//字典树查找
Trie p = root;
int i;
for(i = 0; i < len; i++) {
int k;
if(name[i] == '-') k = 10;
else k = name[i] - '0';
if(p->next[k] == NULL) return -1;
p = p->next[k];
}
return p->key;
}
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
*returnSize = 2;
int *result = (int*)malloc(sizeof(int) * 2);
int i, j;
root = (Trie)malloc(sizeof(struct node));
for(i = 0; i < 11; i++) root->next[i] = NULL;
for(i = 0; i < numsSize; i++) {
char *str;
str = convert(nums[i]);
int len = 0;
while(str[len] != '\0') len++;
trie_insert(str, len, i);
free(str);
}
for(i = 0; i < numsSize; i++) {
int t = target - nums[i];
char *str;
str = convert(t);
int len = 0;
while(str[len] != '\0') len++;
int index = trie_find(str, len);
free(str);
if(index >= 0 && index != i) {
result[0] = i;
result[1] = index;
return result;
}
}
return 0;
}
解法三:排序+双下标
暴力法浪费时间的原因是数组无序,如果数组有序(从小到大),可以一个从前往后一个从后往前遍历,每次检查nums[i] + nums[j]是否为target,如果是结束;否则,如果大了j前移使和减小,如果小了i后移使和增大;算法正确性:因为解存在所以一定可以找到,其次按照这种遍历,i和j一定在最终解的两侧,否则按照有序性和一定大于或小于target。
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int cmp(const void *a, const void *b) {
return (*(int *)a - *(int *)b);
}
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
*returnSize = 2;
int *result = (int*)malloc(sizeof(int) * 2);
int *copy = (int*)malloc(sizeof(int) * numsSize);
int i, j, k;
for(i = 0; i < numsSize; i++) copy[i] = nums[i];
qsort(nums, numsSize, sizeof(nums[0]), cmp);
i = 0;
j = numsSize - 1;
while(i < j) {
int t = nums[i] + nums[j];
if(t == target) {
break;
}
else {
if(t > target) j--;
else i++;
}
}
for(k = 0; k < numsSize; k++) {
if(copy[k] == nums[i]) {
result[0] = k;
break;
}
}
for(k = 0; k < numsSize; k++) {
if(copy[k] == nums[j] && k != result[0]) {//这里注意题目分析中说的
result[1] = k;
break;
}
}
return result;
return 0;
}
第一次刷leetcode,代码小白,不足之处。还望同道们指正