LC1 两数之和

代码如下：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target) {
    static int a[2] = {0};
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] + nums[j] == target) {
                a[0] = i;
                a[1] = j;
                return a;
            }
        }
    }
    return 0;
}

这道题简单，就不做过多解释。

而另一种方法，则是用到基数排序

/*************************************************************************
    > File Name: 1-1.cpp
    > Author: Mr.Lee
    > Mail: 18646139976@163.com
    > Created Time: 五  5/10 11:10:39 2019
 ************************************************************************/

void radix_sort(int *arr, int *main_ind, int n) {
    #define MAX_N 65536
    #define MAX_M 32768
    #define L(x) (x & 0xffff)
    #define H(x) ((x >> 16) & 0xffff)

    int cnt[MAX_N] = {0}, *p;
    int *temp = (int *)malloc(sizeof(int) * n);
    int *ind = (int *)malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) cnt[L(arr[i])] += 1;
    for (int i = 1; i < MAX_N; i++) cnt[i] += cnt[i - 1];
    for (int i = n - 1; i >= 0; i--) {
        temp[--(cnt[L(arr[i])])] = arr[i];
        ind[cnt[L(arr[i])]] = i;
    }
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; i++) cnt[H(temp[i])] += 1;
    for (int i = MAX_M; i < MAX_M + MAX_N; i++) cnt[i % MAX_N] += cnt[(i - 1) % MAX_N];
    for (int i = n - 1; i >= 0; i--) {
        arr[--cnt[H(temp[i])]] = temp[i];
        main_ind[cnt[H(temp[i])]] = ind[i];
    }
    free(temp);
    free(ind);
    return;
}



int *twoSum(int *nums, int numsSize, int target, int *returnSize) {
    int *ind = (int *)malloc(sizeof(int) * numsSize);
    radix_sort(nums, ind, numsSize);
    int p = 0, q = numsSize - 1;
    while (nums[p] + nums[q] != target) {
        if (nums[p] + nums[q] > target) --q;
        else ++p;
    }
    int *ret = (int *)malloc(sizeof(int) * 2);
    ret[0] = ind[p];
    ret[1] = ind[q];
    if (ret[0] > ret[1]) {
        ret[0] ^= ret[1], ret[1] ^= ret[0], ret[0] ^= ret[1];
    }
    free(ind);
    returnSize[0] = 2;
    return ret;
}

还有一种方法，则是哈希表

/*************************************************************************
    > File Name: 1-2.cpp
    > Author: Mr.Lee
    > Mail: 18646139976@163.com
    > Created Time: 五  5/10 11:30:27 2019
 ************************************************************************/

typedef struct Data {
    int val, ind;
}

typedef struct HashTable {
    Data *data;
    int *flag;
    int size;
} HashTable;

HashTable *init(int n) {
    HashTable *h = (HashTable *)malloc(sizeof(HashTable));
    h->data = (Data *)malloc(sizeof(Data) * n);
    h->flag = (int *)calloc(sizeof(int), (n / 32 + 1) );
    h->size = n;
    return h;
}

int hash(int val) {
    return val & 0x7fffffff;
}

int check(HashTable *h, int ind) {
    int x = ind / 32, y = ind % 32;
    return (h->flag[x] & (1LL << y)) != 0;
}

void set(HashTable *h, int ind, Data d) {
    int x = ind / 32, y = ind % 32;
    h->data[ind] = d;
    h->flag[x] |= (1LL << y);
    return;
}

void insert(HashTable *h, int ind, Data d) {
    Data d = {val, val_ind};
    int ind = hash(val) % h->size;
    int time = 1;
    while (check(h, ind)) {
        ind += (time * time);
        ind %= h->size;
    }
    set(h, ind, d);
    return;
}

int query(HashTable *h, int val) {
    int ind = hash(val) % h->size;
    int time = 1;
    while (check(h, ind) && h->data[ind].val != val) {
        ind += (time * time);
        ind %= h->size;
    }
    if (check(h, ind)) return h->data[ind].ind;
    return -1;
}

void clear(HashTable *h) {
    if (h == NULL) return;
    free(h->data);
    free(h->flag);
    free(h);
    return;
}

int *twoSum(int *nums, int numsSize, int target, int *returnSize) {
    HashTable *h = init(numsSize * 3);
    int *ret = (int *)malloc(sizeof(int) * 2);
    for (int i = 0, ind; i < numsSize; i++) {
        if ((ind = query(h, target - nums[i])) == -1) {
            insert(h, nums[i], i);
            continue;
        }
        ret[0] = ind;
        ret[1] = i;
        break;
    }
    returnSize[0] = 2;
    return ret;
}