題目描述：

給定一個整數陣列 nums 和一個目標值 target，請你在該陣列中找出和為目標值的兩個整數。
你可以假設每種輸入只會對應一個答案。但是，你不能重複利用這個陣列中同樣的元素。

示例

給定 nums = [2, 7, 11, 15], target = 9
因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

題目解答：

方法1：暴力解法

兩層for迴圈，思路簡單，但時間複雜度為O(n^2)，較慢，執行時間100ms左右，程式碼如下。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 

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

方法2：HASH

對於查詢目標元素是否存在，hash是一種非常快的方式。但C語言沒有標準的hash函式，所以需要自己實現一個簡單的hash函式，包括插入和查詢。這裡採用拉鍊法hash，即衝突的元素使用連結串列連在一起。因為直接用數字對長度取餘做hash索引，所以需要注意的數字的正負及數字的範圍（是否會超過int的範圍）。對於某一個元素nums[i]

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
struct node {
    long val;
    int index;
    struct node* next;
};
void insert(struct node** hashTable, long val, int index, int n) {
    int t = abs(val) % n;
    struct node* temp = hashTable[t];
    // head-add
    struct node* add = (struct node*)malloc(sizeof(struct node));
    add->val = val;
    add->index = index;
    add->next = temp->next;
    temp->next = add;
}
int search(struct node** hashTable, long target, int n) {
    int index = abs(target) % n;
    struct node* temp = hashTable[index]->next;
    while(temp) {
        if(temp->val == target) {
            return temp->index;
        }
        temp = temp->next;
    }
    return -1;
}
void freeHashTable(struct node** hashTable, int n) {
    int i = 0;
    struct node *temp = NULL, *delete = NULL;
    for(i = 0; i < n; i++) {
        temp = hashTable[i];
        delete = temp;
        while(temp) {
            delete = temp;
            temp = temp->next;
            free(delete);
        }
    }
    free(hashTable);
}
int* twoSum(int* nums, int numsSize, int target) {
    int i = 0, j = 0;
    int n = numsSize, index = 0;
    int* result = NULL;
    struct node** hashTable = (struct node**)malloc(n * sizeof(struct node*));
    // init head node
    for(i = 0; i < n; i++)
        hashTable[i] = (struct node*)calloc(1, sizeof(struct node));
    for(i = 0; i < n; i++) {
        index = search(hashTable, target - nums[i], n);
        if(-1 == index)
            insert(hashTable, nums[i], i, n);
        else {
            result = (int*)malloc(sizeof(int) * 2);
            result[0] = index;
            result[1] = i;
            freeHashTable(hashTable, n);
            return result;
        }    
    }
    freeHashTable(hashTable, n);
    return result;
}

方法3：排序+雙下標

構造結構體，將數字與其原始位置關聯起來。然後對結構體陣列進行排序，從小到大的順序，這裡採用qsort()函式。利用兩個下標begin和end，begin指向於開始的位置，end指向結束的位置，判斷nums[begin] + nums[end]與target的關係，如果相等，則直接返回索引；如果比target大，則說明需要減小兩數之和，即end--，來減小後者數字；如果比target大，則說明需要增大兩數之和，即begin++來增大前者數字。通過這種方式逐漸逼近target，執行時間0ms，程式碼如下。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
struct node {
    int val;
    int index;
};
int comp(const void* a, const void* b) {
    return (((struct node*)a)->val > ((struct node*)b)->val ? 1 : -1);
}
int* twoSum(int* nums, int numsSize, int target) {
    int i = 0;
    int n = numsSize;
    int begin = 0, end = n - 1;
    int* result = NULL;
    struct node* nodes = (struct node*)malloc(n * sizeof(struct node));
    // init nodes
    for(i = 0; i < n; i++) {
        nodes[i].val = nums[i];
        nodes[i].index = i;
    }
    qsort(nodes, n, sizeof(struct node), comp);
    while(begin < end) {
        if(nodes[begin].val + nodes[end].val == target) {
            result = (int*)malloc(sizeof(int) * 2);
            result[0] = nodes[begin].index;
            result[1] = nodes[end].index;
            free(nodes);
            return result;
        }
        else if(nodes[begin].val + nodes[end].val > target)
            end--;
        else
            begin++;            
    }
    free(nodes);
    return result;
}