leetcode每日三题_day1

1. 两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

暴力一下

int *twoSum(int *nums, int numsSize, int target, int *returnSize)
{
    int *result = (int *)malloc(sizeof(int) * 2);
    for (int i = 0; i < numsSize - 1; i++)
    {
        for (int j = i + 1; j < numsSize; j++)
        {
            if (nums[i] + nums[j] == target)
            {
                result[0] = i;
                result[1] = j;
                *returnSize = 2;
                return result;
            }
        }
    }
    return result;
}

hash一下

typedef struct HashNode
{
	int key;
	int value;
	struct HashNode * next;
}HashNode;

typedef struct HashMap
{
	int size;
	HashNode * table;
}HashMap;

HashMap * CreateHashMap(int *nums,int numSize)
{
	int i;
	int index=0;
	HashMap *hashmap = (HashMap *)malloc(sizeof(HashMap));		
	hashmap->size = numSize;
	hashmap->table = (HashNode *)malloc(sizeof(HashNode)*hashmap->size);	


	for(i=0;i<hashmap->size;i++)
	{
		hashmap->table[i].value = INT_MIN;
		hashmap->table[i].next = NULL;
	}


	while(index<numSize)
	{
		int place = abs(nums[index])%(hashmap->size);
		if(hashmap->table[place].value == INT_MIN)
		{
			hashmap->table[place].value = nums[index];
			hashmap->table[place].key = index;
		}
		else
		{
			HashNode * node_1 = (HashNode *)malloc(sizeof(HashNode));
			HashNode * hashnode;
			node_1->value = nums[index];
			node_1->key = index;
			node_1->next = NULL;

			hashnode = &(hashmap->table[place]);
			while(hashnode->next != NULL)
			{
				hashnode = hashnode->next;
			}
			hashnode->next = node_1;
		}
		index++;
	}
	return hashmap;
}

int GetHashMap(HashMap * hashmap, int value)
{
	int place = abs(value)%(hashmap->size);
	HashNode * pointer = &(hashmap->table[place]);
	while(pointer != NULL)
	{
		if(pointer->value == value)
		{
			return pointer->key;
		}
		else
		{
			pointer = pointer->next;
		}
	}
	return -1;
}

void freeHashMap(HashMap * hashmap)
{
	int i=0;
	HashNode * Fpointer;
	while(i<hashmap->size)
	{
		Fpointer = hashmap->table[i].next;
		while(Fpointer != NULL)
		{
			hashmap->table[i].next = Fpointer->next;
			free(Fpointer);
			Fpointer = hashmap->table[i].next;
		}
		i++;
	}
	free(hashmap->table);
	free(hashmap);
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize)
{
	int i;
	int key=0;
	HashMap * hashmap = CreateHashMap(nums,numsSize);
	int * res = (int *)malloc(sizeof(int)*2);
	* returnSize = 0;
	for(i=0;i<numsSize;i++)
	{
		int value = target - nums[i]; 
		key = GetHashMap(hashmap,value);
		if(key !=-1 && key != i)
		{
			res[0] = i;
			res[1] = key;
            * returnSize=2;
			break;
		}
	}
	freeHashMap(hashmap);
	return res;
}

//测试代码

记录一下第一次使用hashmap

第一步建立哈希表的数据结构
hashnode 每一个节点的数据结构，包括key，value，next指针
hashmap整个结构属性，包括结构大小，多少个初始化node

---

第二步初始化hashmap
给HashNode，HashMap地址空间，HashMap大小为size
HashMap中所有节点value初始化
定义哈希函数，将数据处理
判断当前位置是否冲突，不冲突则放入；冲突时申请一个新的HashNode，以及一个操作HashNode，将数据信息赋予新的HashNode，通过操作HashNode将新的Node放到最后

---

第三步查找元素
通过和第二步一样的哈希函数对传入数据进行处理
申请一个操作HashNode来指导计算出来的地址
判断改地址里的值和传入值是否相同，相同则返回key，即原数组中索引；不相同判断是否还有next，有的话重复操作判断；没有的话返回该地址下没有

---

第四步释放HashMap空间
需要逐步释放每一个Node上的链表节点
从HashMap第一个Node开始，申请一个新的Node指向该Node，判断该Node下是否还有Node

2. 两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
示例
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

这是我能想到的一个做法，很简单的一个思路，但时间方面有所欠缺

    struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2){
        if(l1==NULL&&l2==NULL){
            return false;
        }
        else if(l1==NULL){
            return l2;
        }
        else if(l2==NULL){
            return  l1;
        }

        int addflag=0;
        struct ListNode* result = (struct ListNode*)malloc(sizeof(struct ListNode));
        result->next = NULL;
        struct ListNode* cur = result;

        while(l1!=NULL&&l2!=NULL){
            struct ListNode* tmp = (struct ListNode*)malloc(sizeof(struct ListNode));
            tmp->next = NULL;

            int sum=l1->val+l2->val+addflag;
            addflag = sum /10;
            sum = sum%10;
            cur->val = sum;
            cur->next = tmp;

            if(l1->next==NULL&&l2->next==NULL){
                if(addflag!=0){
                    cur = cur->next;
                    cur->next = tmp;
                    cur->val=addflag;
                    tmp->next=NULL;
                }
                else{
                    cur->next = NULL;
                }
                return result;
            }

            else if(l1->next==NULL){
                l1->val=0;
                l2=l2->next;
            }
            else if(l2->next==NULL){
                l2->val=0;
                l1=l1->next;
            }
            else{
                l1=l1->next;
                l2=l2->next;
            }
            cur = cur->next;
        }
        return;
    }

3. 无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

和2差不多原理，记录元素位置。

int lengthOfLongestSubstring(char * s){
    int index[128] = {0};
    int start=0,max=0,count=0;
    int i;
    for( i=0;s[i]!='\0';i++)
    {
        if(index[s[i]]>start)
        {
            count = i - start;
            printf("count = %d\n",count);
            start = index[s[i]];
            if(count>max)
            {
                max = count;
            }            

        }
        index[s[i]] = i+1;
    }
    count = i - start;
     if(count>max)
    {
        max = count;
    } 
    return max;
}