blocks|key|2018157|text|比较是一次还是多次？如果只做一次比较，那么你最好直接进行比较。如果您需要将大量字符串与这组常量字符串进行比较，那么从长远来看，您可以通过使用散列来节省时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2018158|这是一个足够简单的问题，您可以很容易地以两种方式编写它，并查看哪种方式对一组代表性的输入更有效。|2018159|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Is the comparison going to be done once or many times? If the comparison is going to be done only once then you are likely better off doing a straight comparison. If you are going to need to compare very many strings to this set of constant strings, then you can probably save time in the long run by doing it with hashes.

This is a simple enough problem that you can easily write it both ways and see which works better for a representative set of input.

blocks|key|104673|text|散列值的相等并不能保证相等--尽管不匹配会保证不平等。如果你需要比较大量的字符串和你的集合，hash会很棒--如果是一次性的比较(我猜不太可能)，那么strcmp会做得很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|104674|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|$]]

Equality of a hash value does not guarantee equality - a mismatch will guarantee inequality, though. If you're going to need to compare a lot of strings against your collection the a hash would be great - if it's a one-off comparison (unlikely I guess) then strcmp will do nicely.

blocks|key|2791999|text|那得看情况。散列算法是什么？字符串有多长？平台是什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2792000|另请注意，匹配的散列不能保证字符串匹配。|2792001|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It depends. What's the hashing algorithm? How long are the strings? What's the platform?

Also note that a matching hash doesn't guarantee matching strings.

blocks|key|2011692|text|这在很大程度上取决于字符串的长度和散列函数的复杂性。实现并测试自己将是最好的答案……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2011693|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|$]]

It greatly depends on the length of the strings and the complexity of your hash function. Implement and benchmark yourself would be the best answer...

blocks|key|2018183|text|如果您正在尝试将一个主题字符串与一组其他字符串进行匹配，则可以考虑使用Aho-Corasick+String+Matching+Algorithm。它使用trie在单次传递中将主题与所有目标字符串进行匹配(它的实现也非常简单)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2018184|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Aho%25E2%2580%2593Corasick_string_matching_algorithm^0|Z|12|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If you are trying to match a subject string against a set of other strings, you might consider using the <a href="http://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_string_matching_algorithm" rel="nofollow noreferrer">Aho-Corasick String Matching Algorithm</a>. It uses a trie to match the subject against all of the target strings in a single pass (it's also quite simple to implement).

blocks|key|4905114|text|另一种可行的方法是对常量字符串进行排序，并对字符串进行二分法搜索，这样最多只能进行log2(n)比较(例如，1024个字符串只有10个比较，1000000个字符串甚至只有20个比较)。我不知道它是否适用于你的问题，但我用这种方法得到了非常好的结果。散列真的很难正确处理，转角情况会变得非常糟糕，而且密钥的计算通常会非常昂贵。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4905115|entityMap^0|15|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Another approach that could work, is to have your constant string sorted and making a dichotomic search of your string, this way you only have at most <code>log2(n)</code> comparisons (that's for example only 10 comparisons for 1024 strings or even only 20 for 1000000 strings).
I don't know if it is applicable to your problem but I had really good results with that approach. Hashing is really difficult to get right, the corner cases can get really nasty and the computation of the key can often be quite costly.

blocks|key|2011700|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2011701|，谢谢你的回答，我会做很多比较。有人能给我一个好的，快速的，低资源消耗的算法吗？我所知道的唯一的哈希是MD5，我有一种感觉，那就是结束kill。|blockquote|2011702|2011703|2011704|Murmur+hash简单、快速，在统计测试中表现良好。|offset|length|2011705|entityMap|0|LINK|mutability|MUTABLE|url|http://sites.google.com/site/murmurhash/^0|0|0|0|0|0|B|0|0^^$0|@$1|2|3|-4|4|5|6|R|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|S|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|T|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|U|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|V|7|@]|8|@$H|W|I|X|1|Y]]|9|$]]|$1|J|3|-4|4|5|6|Z|7|@]|8|@]|9|$]]]|K|$L|$4|M|N|O|9|$P|Q]]]]

<blockquote>
 thank you for the answers I am going
 to be doing many comparisons. can
 anyone give me a good, fast, low
 resource intensive algorithm to use?
 The only hash I know of is MD5 and I
 have a feeling that is over kill.
</blockquote>

<a href="http://sites.google.com/site/murmurhash/" rel="nofollow noreferrer">Murmur hash</a> is simple, fast and behaves well on statistical tests.

blocks|key|106614|text|这很难取得进展，字符串散列函数是O(n)。字符串比较也是O(n)，只有一个更小的Oh。只有当您能够存储您计算的散列值并重复使用它们时，您才会领先。对两个人都是。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|106615|简单的示例C散列函数are+here。|offset|length|106616|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cse.yorku.ca/~oz/hash.html^0|0|A|8|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

It's difficult to get ahead, string hashing functions are O(n). String comparison is O(n) as well, with a smaller Oh. You would only be ahead if you can store the hash values you compute and use them repeatedly. For both.

Simple sample C hash functions <a href="http://www.cse.yorku.ca/~oz/hash.html" rel="noreferrer">are here</a>.

blocks|key|2792127|text|我认为如果你有一个静态的字符串列表，我会将它们存储在一个排序的数组中，然后使用bsearch来确定一个字符串是否在这个列表中。如果值不存在，则返回NULL；如果值存在，则返回指向该值的指针，并且可能比线性搜索或散列更快。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2792128|#include+<stdio.h>
#include+<stdlib.h>
#include+<string.h>

/*+cmp+function+for+qsort+and+bsearch+*/
static+int+pstrcmp(const+void+*a,+const+void+*b)
{
++return+strcmp(*(char+*+const+*)a,+*(char+*+const+*)b);
}

/*+check+an+input+against+the+list+of+known+strings+*/
static+char+*check_for_match(char+*input)
{
++static+char+*static_list[]+=+{+"one",+"two",+"three",+"four",+"five"+};
++static+int+nelems;

++/*+this+sorts+the+list,+for+demonstration+purposes,+but+if+the+list
+++++is+static+then+it+could+be+sorted+prior+to+compiling+*/
++if+(!+nelems)
++{
++++nelems+=+sizeof(static_list)+/+sizeof(*static_list);
++++qsort(static_list,+nelems,+sizeof(*static_list),+pstrcmp);
++}


++return+bsearch(&input,+static_list,+nelems,+sizeof(*static_list),+pstrcmp);
}

int+main(int+argc,+char+*argv[])
{
++if+(check_for_match("should_not_match"))
++{
++++printf("Match+found.\n");
++}+else+{
++++printf("No+match+found.\n");
++}

++if+(check_for_match("two"))
++{
++++printf("Match+found.\n");
++}+else+{
++++printf("No+match+found.\n");
++}
++return+EXIT_SUCCESS;
}|code-block|syntax|javascript|2792129|entityMap^0|13|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I think if you have a static list of strings, I would store them in a sorted array and then use <code>bsearch</code> to determine if a string is in that list. This returns NULL if it does not exist, or a pointer to the value should it exist and is probably faster than a linear search or hashing.

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;

/* cmp function for qsort and bsearch */
static int pstrcmp(const void *a, const void *b)
{
 return strcmp(*(char * const *)a, *(char * const *)b);
}

/* check an input against the list of known strings */
static char *check_for_match(char *input)
{
 static char *static_list[] = { "one", "two", "three", "four", "five" };
 static int nelems;

 /* this sorts the list, for demonstration purposes, but if the list
 is static then it could be sorted prior to compiling */
 if (! nelems)
 {
 nelems = sizeof(static_list) / sizeof(*static_list);
 qsort(static_list, nelems, sizeof(*static_list), pstrcmp);
 }


 return bsearch(&amp;input, static_list, nelems, sizeof(*static_list), pstrcmp);
}

int main(int argc, char *argv[])
{
 if (check_for_match("should_not_match"))
 {
 printf("Match found.\n");
 } else {
 printf("No match found.\n");
 }

 if (check_for_match("two"))
 {
 printf("Match found.\n");
 } else {
 printf("No match found.\n");
 }
 return EXIT_SUCCESS;
}
</code></pre>

blocks|key|4905265|text|如果您的常量字符串在编译时是已知的，请看一下“完美散列”的概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4905266|维基百科:集合S的完美哈希函数是一个哈希函数，它将S中的不同元素映射为不同的整数，而不会发生冲突。|4905267|“无冲突”这件事节省了你的工作。进一步阅读和实现的可能性包括：|4905268|http://cmph.sourceforge.net/|offset|length|4905269|gperf+--+http://www.gnu.org/software/gperf/|unordered-list-item|4905270|
+|4905271|cmph|4905272|4905273|entityMap|0|LINK|mutability|MUTABLE|url|1|http://www.gnu.org/software/gperf/^0|0|0|0|0|S|0|0|9|Y|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@$H|14|I|15|1|16]]|A|$]]|$1|J|3|K|5|L|7|17|8|@]|9|@$H|18|I|19|1|1A]]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|L|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|G]]|Y|$5|U|V|W|A|$X|Z]]]]

If your constant strings are known at compile time, take a look at the idea of a "perfect hash".

Wikipedia: A perfect hash function for a set S is a hash function that maps distinct elements in S to distinct integers, with no collisions.

That "no collisions" thing saves you work. Possibilities for further reading and implementations are:

<ul>
<li>cmph -- <a href="http://cmph.sourceforge.net/" rel="nofollow noreferrer">http://cmph.sourceforge.net/</a></li>
<li>gperf -- <a href="http://www.gnu.org/software/gperf/" rel="nofollow noreferrer">http://www.gnu.org/software/gperf/</a></li>
</ul>

blocks|key|4905373|text|直接回答你的问题，如果你只是比较两个字符串(你也可以考虑两个文件，两个视频等)，做一个字符比较和散列都是O(N)，做散列方式没有明显的优势。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4905374|然而，如果字符串可以改变，则散列在第二次运行中将更有效，例如，滚动散列https://en.wikipedia.org/wiki/Rolling_hash|offset|length|4905375|此外，字符串/文件的哈希就像指纹一样，下次想要比较另一个字符串是否与此字符串相同时，可以直接比较哈希值|4905376|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Rolling_hash^0|0|Z|16|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

To answer your question directly, if you are just comparing if two strings (you can also think about two files, two videos etc), doing a char by char comparison and hashing are both O(N), there is no obvious advantage doing it hash way. 

However, if the string can change, then hashing would be more efficient in the 2nd run, e.g., rolling hash <a href="https://en.wikipedia.org/wiki/Rolling_hash" rel="nofollow noreferrer">https://en.wikipedia.org/wiki/Rolling_hash</a>

Moreover, hashing of a string/file is like a fingerprint, you can directly compare the hash value next time you want to compare if another string is the same as this one or not

I need to compare a string to multiple other constant strings in c. I am curious which is faster, to hash the string I am going to compare and compare it to all the other constant string hashes or just compare the strings as strings. thank you in advance

thank you for the answers I am going to be doing many comparisons. can anyone give me a good, fast, low resource intensive algorithm to use? The only hash I know of is MD5 and I have a feeling that is over kill.

I also want to add that the strings are maybe 20 or 30 characters long at the max with most being around 7.

c string compare vs hash compare

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我需要将一个字符串与c中的多个其他常量字符串进行比较，我很好奇哪个更快，为了对字符串进行散列，我会将它与所有其他常量字符串散列进行比较，或者只是将字符串作为字符串进行比较。提前谢谢你谢谢你的回答，我将做很多比较。有人能给我一个好的，快速的，低资源消耗的算法吗？我所知道的唯一的哈希是MD5，我有一种感觉，那就是结束kil...

问C字符串比较与散列比较
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C字符串比较与散列比较EN