blocks|key|5302356|text|首先使用qsort对列表进行排序，然后使用bsearch查找项目。它不是O(1)，但至少是O(log(n))。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5302357|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/c/algorithm/qsort|1|http://en.cppreference.com/w/c/algorithm/bsearch^0|4|5|L|7|4|5|0|L|7|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]|$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

Sort your list with <a href="http://en.cppreference.com/w/c/algorithm/qsort" rel="nofollow"><code>qsort</code></a> first, and then use <a href="http://en.cppreference.com/w/c/algorithm/bsearch" rel="nofollow"><code>bsearch</code></a> to find items. It's not O(1), but at least it is O(log(n)).

blocks|key|5302386|text|最简单的方法是实现查找表，最好是按整数值(“主键”)排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5302387|typedef+enum
{
++FOO_INDEX,
++BAR_INDEX,
++...++
++N
}+some_t;

const+int+int_array+[]+=++//+values+sorted+in+ascending+order,+smallest+first
{
++45,
++1023,
++...
};

const+char*+str_array+[]+=
{
++"foo",
++"bar",
++...
};|code-block|syntax|javascript|5302388|现在，您可以使用int_array[FOO_INDEX]和str_array[FOO_INDEX]来获取所需的数据。|offset|length|style|CODE|5302389|由于这些表是在编译时设置的常量表，因此可以对数据进行排序。然后，所有的查找都可以用二进制搜索O(log+)完成。如果您有整数值，但需要知道索引，请在int_array上执行二进制搜索。一旦你找到了索引，你就可以从那里得到即时的查询。|5302390|为此，两个数组必须具有完全相同的N大小。要确保数组大小和这些数组中的数据完整性，请使用编译时断言：|5302391|static_assert(sizeof(int_array)/sizeof(*int_array)+==+N,+"Bad+int_array");
static_assert(sizeof(str_array)/sizeof(*str_array)+==+N,+"Bad+str_array");|5302392|entityMap^0|0|0|8|K|T|K|0|0|G|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

The easiest way is to implement lookup tables, preferably sorted by the integer value ("primary key").

<pre><code>typedef enum
{
 FOO_INDEX,
 BAR_INDEX,
 ... 
 N
} some_t;

const int int_array [] = // values sorted in ascending order, smallest first
{
 45,
 1023,
 ...
};

const char* str_array [] =
{
 "foo",
 "bar",
 ...
};
</code></pre>

Now you can use <code>int_array[FOO_INDEX]</code> and <code>str_array[FOO_INDEX]</code> to get the desired data. 

Since these are constant tables set at compile-time, you can sort the data. All lookups can then be done with binary search, O(log n). If you have the integer value but need to know the index, perform a binary search on the int_array. And once you have found the index, you get instant lookup from there.

For this to work, both arrays must have the exact size <code>N</code>. To ensure array sizes and data integrity inside those arrays, use a compile-time assert:

<pre><code>static_assert(sizeof(int_array)/sizeof(*int_array) == N, "Bad int_array");
static_assert(sizeof(str_array)/sizeof(*str_array) == N, "Bad str_array");
</code></pre>

blocks|key|5302435|text|使用两个哈希图。一个用于从整数到字符串的关联，另一个用于从字符串到整数的关联。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5302436|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Use two hashmaps. One for the association from integer to string and another one for the association from string to integer.

blocks|key|3834183|text|一种低效的方法是将它转换为基数256。第一个字母-ASCII乘以0+(1)的256次方，加上第二个字母-ASCII乘以1的256次方，依此类推。效率非常低(因为long还不够，所以要么将数字包含在另一个字符串中，要么使用数学C库。我知道在Ruby和Perl中有散列，它基本上是一个数组，你可以用某个键(可以是一个字符串)进入它，但我不知道它是如何工作的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3834184|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

An inefficient way would be to kind of convert it to base 256. First-letter-ASCII times 256 in the power of 0 (1) PLUS Second-letter-ASCII times 256 in the power of 1 and so on. Very inefficient (Because long won't be enough so either contain the number in another string or use a mathematical C library. I know there are hashes in Ruby and Perl and it's basically an array that you get into with a certain key (can be a string) but I don't know how it's working.

I'd like a suggestion in c language for the following problem:

I need an association between strings and integers like this:

<pre><code>"foo" =&gt; 45,
"bar" =&gt; 1023,
 etc...
</code></pre>

and be able to find the string using the associated integer and the integer using the associated string.
For string to integer I can use hash tables but I'll loose the way back.

The simple solution that I'm using but which is very slow is to create a table:
 static param_t params [] = {
 { "foo", 45 },
 { "bar", 1023 },
 ...
 };
and using two functions compare each entry (string or integer) to get the string or the integer.
This works perfectly by this is linear search which is very slow.
What could I use to have a search algorithm in O(1) to find a string and O(size of string) to find the integer?
Any ideas?

string/integer associations in C

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

对于下面的问题，我想用c语言给出一个建议：我需要字符串和整数之间的关联，如下所示："foo" => 45,"bar" => 1023, etc...并且能够使用相关联的整数找到该字符串，并且能够使用相关联的字符串找到该整数。对于字符串到整数，我可以使用哈希表，但我将失去返回的方法。我使用的简单解决方案是创建一个表: s...

问C语言中的字符串/整数关联
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C语言中的字符串/整数关联EN