Question

我在此链接https://leetcode.com/problems/contains-duplicate/中遇到问题。有一个整数输入数组。找出是否存在重复的整数，然后返回true，否则返回false。

如何优化此代码？
我可以进一步改善逻辑吗？

在下面的代码中，有一个if条件if(hPtr && hPtr->key == *(nums+i))。我正在使用数组元素作为键。如果是这样，如果同一元素重复两次，每个键就不能唯一吗？我可以将if条件修改为if(hPtr->key == *(nums + i))?

如果还有其他错误，请随时指出。

C http://troydhanson.github.io/uthash/userguide.html中已经有一个哈希表库，并编写了以下代码。

struct hash {
        int key;
        int value;
        UT_hash_handle hh;
};

    struct hash *hashtable = NULL;

    void addToHash(int key, int value)
    {
      struct hash *map;
      //I am using the array elements as hash keys
      HASH_FIND_INT(hashtable, &key, map);

      if(map == NULL)
      {
        map = (struct hash*)malloc(sizeof(struct hash));
        map->key = key;
        HASH_ADD_INT(hashtable, key, map);
      }     
      map->value = value;
    }   

    struct hash *findInHash(int key)
    {
        struct hash *h;
        HASH_FIND_INT(hashtable, &key, h);
        return h;
    }

    bool containsDuplicate(int* nums, int numsSize) {
        struct hash *hPtr;
        int target = 0;
        hashtable = NULL;
        if((numsSize <= 1) || (nums == 0)) return false;

        int i, index1 = 0;   

        for(i = 0; i < numsSize; i++)
        {
            /*The below statement will look if the key is already present in 
              the hashtable*/
            hPtr = findInHash(*(nums + i) - target);
            /*If the key is found already, then it look for the value of that 
            key. If the value and the current array element is same, then a 
            duplicate exist*/
            if(hPtr && hPtr->key == *(nums+i))
               return true;
            addToHash(*(nums + i), i);
        }
        struct hash *temp;
        HASH_ITER(hh, hashtable, hPtr, temp) {free(hPtr);}
        return false;
    }

Answer 1

我认为解决方案比您想象的要简单：

typedef struct {
  int capacity;
  int len;
  int **keys;
  int *values;
} Map;

我的结构的键是由两个整数组成的数组，一个是标识符，另一个是values数组的索引，这就是哈希映射的工作原理。

void initMap(Map *map) {
  map -> capacity = 5;
  map -> len = 0;
  map -> keys = malloc(map -> capacity * sizeof(int));
  map -> values = malloc(map -> capacity * sizeof(int));
}

然后我们有一个初始化地图的函数，简单...

void add(Map *map, int k, int v) {
  if (map -> len == map -> capacity - 1) resize(map);
  map -> values[map -> len] = v;
  map -> keys[map -> len] = malloc(sizeof(int) * 2);
  map -> keys[map -> len][0] = k;
  map -> keys[map -> len][1] = map -> len;
  map -> len++;
}

在地图上放置元素的功能

void resize(Map *map) {
  map -> capacity *= 2;
  map -> keys = realloc(map -> keys, map -> capacity * sizeof(int) * 2);
  map -> values = realloc(map -> keys, map -> capacity * sizeof(int));
}

以及在达到限制时调整地图大小的功能

通过将键索引和values数组上的索引解耦，可以对键进行排序，从而使工作更加轻松。这些值将以与它们相同的顺序出现在它们的数组中，但是索引将按从0到N的顺序排序。为此，我将使用一个简单的selsort算法，它不是最好的，但是最简单的...

void sort(Map *map) {
  int i, j;
  int min, tmp;
  for (i = 0; i < map -> len - 1; i++) {
    min = i;
    for (j = i + 1; j < map -> len; j++) {
      if(map -> keys[j][0] < map -> keys[min][0] ) min = j;
    }

    tmp = map -> keys[min][0];
    map -> keys[min][0] = map -> keys[i][0];
    map -> keys[i][0] = tmp;
  }
}

与此有关，您将缩短索引。在将新条目添加到地图后，我会在add（）函数内部立即执行它，现在就在这里进行测试。

对索引进行排序后，就可以编写二进制搜索算法eeeasy。现在，您可以在地图中是否已有钥匙。

int find_recursive(Map *map, int start, int end, int key) {
   if (end >= start) {
        int mid = start + (end - start) / 2;

        if (map -> keys[mid][0] == key)
            return mid;

        if (map -> keys[mid][0] > key)
            return find_recursive(map, start, mid - 1, key);

        return find_recursive(map, mid + 1, end, key);
    }
    return -1;
}

int find(Map *map, int key) {
    return find_recursive(map, 0, map -> len, key);
}

很好

  Map map;
  initMap(&map);

  add(&map, 3, 12);
  add(&map, 12, 1);
  add(&map, 1, 2);

  printf("%d %d %d\n",
      map.keys[0][0],
      map.keys[1][0],
      map.keys[2][0]
      );
  // Should print 3 12 1

  sort(&map);

  printf("%d %d %d\n",
      map.keys[0][0],
      map.keys[1][0],
      map.keys[2][0]
      );
  // Should print 1 3 12

  printf("%d\n", find(&map, 12));
  // Should print 2 (the index, 3rd entry)

我现在不能做一个有效的例子，我不能用我的机器编译，也许以后在家...抱歉：（

编辑：忘记说...要获得您必须做的map.values[map.keys[find(&map, key)][1]]的价值。

当然这应该是一个函数：

int get(Map *map, key) {
  int keyindex = find(map, key);
  int valueindex = map -> keys[index][1];
  return map -> values[valueindex];
}

忘记说了，通过将键与值分离，您可以将任意类型的值用作值，甚至是整个结构...

享受

使用C

1 个答案: