leetcode第一題<>

很久沒更新博客了，我都不知道每天在忙什麼，歲數大了，人就懶了，之前的具體數學博客實在是寫不動了，看了幾章就扔去墊顯示器了，最近忽然想起來刷刷leetcode了，不知道爲何。好了，話很少，從0開始刷leetcode,也不知道我能堅持多久，反正慢慢來，常常作題確定會進步的。。

1. Two Sum

My Submissions

QuestionEditorial Solution

Total Accepted: 212403 Total Submissions: 943126 Difficulty: Easy

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

題目傳送門:Two sum

下面說說個人思路吧:這題當時我拿到手就感受很容易啊，因而不到15分鐘就代碼ok，提交也過了

這道題目最容易想的方法是暴力法，就是用兩個for循環遍歷每一種可能的組合，並判斷結果是否等於target。這種方法的時間複雜度是O(n^2)，代碼以下:

int* twoSum(int* nums, int numsSize, int target) {
    if ((nums == NULL)|(numsSize < 2))
    {
        return NULL;
    }
    int i;
    int j;
    int* index = (int*)malloc(sizeof(int)*2);
    for (i = 0; i< numsSize; i++)
    {
        for (j = i + 1; j < numsSize; j++)
        {
            int tmp = nums[i] + nums[j];
            if (tmp == target)
            {
                index[0] = i;
                index[1] = j;
                return index;
            }
        }
    }
    return NULL;
}

而後我就提交經過了，由於之前看過不少數據結構或者算法競賽的書，就感受這個也太簡單了，而並且傳說之前這種方法是不給經過的，時間複雜度過高了，就去網上搜了一下別人的方法，有個osc的大兄弟是這樣解的:

用hash表：只需遍歷一遍數組，若是nums[i]沒有在hash表中，則將target-nums[i]做爲鍵， i做爲值存儲在hash表中。不然找到，返回hash表中鍵爲nums[i]的鍵值對的值，並計算兩個索引返回。這種方法時間複雜度是O(n)。他的代碼以下(他居然本身寫了一個hash函數):

int * twoSum(int* nums, int numsSize, int target) {    int * indexs;    int i;

    indexs = (int *)malloc(2 * sizeof(int));    memset(indexs, 0, sizeof(indexs));

    node * ht[N];    for(i = 0; i < N; i++)
    {
        ht[i] = NULL;
    }    for(i = 0; i < numsSize; i++)
    {
        node * p = search_by_key(ht, nums[i]);        if(p)
        {            /*若是存在，那麼找到，索引爲p->data.value+1和i+1 */
            indexs[0] = p->data.value + 1;
            indexs[1] = i + 1;            return indexs;
        }        else
        {            /* 若是不存在，就將target-nums[i]，i存儲在哈希表中*/
            insert(ht, target-nums[i], i);
        }
    }    return indexs;
}
#define N 100#define abs(x) (((x)>0)?(x):(-x))typedef struct DATATYPE{    int key;    int value;
}data_type;typedef struct NODE{
    data_type   data;    struct NODE * next;
}node;/**
* 搜索hash表
*/node * search_by_key(node * ht[N], int key)
{
    node * p;    int addr = abs(key % N);
    p = ht[addr];    while(p && p->data.key != key)
        p = p->next;    return p;
}/**
* 插入hash表
*/void insert(node * ht[N], int key, int value){    int addr;
    node * p, * s;

    s = (node *)malloc(sizeof(node));
    s->data.key = key;
    s->data.value = value;

    p = search_by_key(ht, key);    if(p)
    {/*記錄存在*/
        free(s);
    }    else
    {
        addr = abs(s->data.key % N);
        s->next = ht[addr];
        ht[addr] = s;
    }
}

他也提示了還有一種方法:先把數組從小到大排序，再用兩個指針從數組兩頭向中間夾。初始時left = 0，rigth = numsSize-1，而後若是nums[left] + nums[right] < target，則left++；若是nums[left] + nums[right] > target，則right--；不然找到結果並返回。在這一題中這種思路有個問題是要主要保存排序前數字對應的索引。這種方法時間複雜度是O(nlogn)。

我不知道我這個算不算抄襲別人的知識成果，其實，我看別人的只是想拓寬一下本身的思路，雖然複製黏貼了。。

最後，想說，距離上篇博客已經一年，這一年其實很快，也發生過不少事，一句話：何須回頭傷往事 且把風流唱少年！！