计算每个字母在字符串中出现的次数

Question

我一直在使用一些旧代码，并且遇到了我不久前创建的一个函数，它计算每个字母在给定字符串中出现的次数。在我的初始函数中，我将遍历字符串 26 次，计算每个字母在循环中出现的次数。但是，我知道这确实效率低下，所以我尝试这样做：

int *frequency_table(char *string) { 
    int i;
    char c;
    int *freqCount = NULL;
    freqCount = mallocPtr(freqCount, 26, sizeof(int), "freqCount"); /* mallocs and checks for out of memory */

    for (i = 0; string[i] != '\0'; i++) {
        c = string[i];
        if (isalpha(c)) {
            isupper(c) ? freqCount[c - 65]++ : freqCount[c - 97]++;
        }
    }

    return (freqCount);
}

上面的代码循环遍历一个字符串并检查每个字符。如果字符是字母（az 或 AZ），那么我会在 freqCount 数组中的特定索引处增加频率计数（其中索引 0 = a\A, 1 = b\B, ... , 25 = Z Z）。

代码似乎计算得很好，但是当我打印数组时，我得到以下输出：

字符串：“abcdefghijklmnopqrstuvwxyziii”

a/A     -1276558703
b/B     32754
c/C     -1276558703
d/D     32754
e/E     862570673
f/F     21987
g/G     862570673
h/H     21987
i/I     4
j/J     1
k/K     1
l/L     1
m/M     1
n/N     1
o/O     1
p/P     1
q/Q     1
r/R     1
s/S     1
t/T     1
u/U     1
v/V     1
w/W     1
x/X     1
y/Y     1
z/Z     1

作为参考，我按以下方式打印数组：

for (i = 0; i < 26; i++) {
     printf("%c/%c     %d\n", i + 97, i + 65, freqCount[i]);
}

我检查以确保指针分配正确，我确定我没有覆盖这个内存位置。也许我遗漏了一些东西，但我真的不明白为什么它会从 a\A-h\H 打印垃圾内存值。

另外，如果有更有效的方法来做我想做的事，我很想听听。

谢谢

Answer 1

• 正如许多人提到的，您必须将 value 初始化为 0
• 您还可以使用以下技巧来加快字母计数：如果是字母，则清除第 32 位，这是大写和小写之间的位差，这将为您提供正确的索引。
• 最后，您可以使用短数组，除非您期望有很多字母。

#include <stdio.h>
#include <stdlib.h>

short *frequency_table(char *string){ 
    char c;
    short *freqCount;

    if (!(freqCount = (short*)calloc(26, sizeof(short))))
        return NULL;

    for(int i = 0; (c = string[i]) != '\0'; i++) {
        if(isalpha(c))
            freqCount[(c & ~32) - 'A']++;
    }

    return(freqCount);
}

主要测试：

int main() {
    short *n = frequency_table("helloiHEllo6456gdrgd#%#^#$^#_thirde");

    for (char c = 'a'; c <= 'z'; c++)
         printf("%c: %d\n", c, n[c - 'a']);
    return 0;
}

Answer 2

你的代码有两个问题：

• 数组freqCount 未初始化。
• 您应该避免将char 值传递给isalpha，因为如果string 在默认签名char 的系统上包含负的char 值，则会导致未定义的行为。

代替三元运算符或if 语句，您可以使用toupper() 将小写字符转换为大写，并且使用'A' 或'a' 而不是硬编码的ASCII 值@ 更具可读性987654331@和97。

这是一个更正的版本：

int *frequency_table(const char *string) { 
    size_t i;

    /* allocate the array with malloc and check for out of memory */
    int *freqCount = mallocPtr(freqCount, 26, sizeof(int), "freqCount");

    for (i = 0; i < 26; i++) {
        freqCount[i] = 0;
    }
    for (i = 0; string[i] != '\0'; i++) {
        unsigned char c = string[i];
        if (isalpha(c)) {
            /* this code assumes ASCII, so 'Z'-'A' == 25 */
            freqCount[toupper(c) - 'A']++;
        }
    }
    return freqCount;
}

Answer 3

以下建议的代码：

1. 避免malloc()、calloc()等
2. 在main()函数中保留数据等的定义
3. 执行所需的功能
4. 干净编译
5. 使用简单的字符而不是“魔术”数字
6. 需要 ASCII 字符集

现在，建议的代码：

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

#define MAX_ALPHA  26

void charCounter( char *,  int * );

int main( void )
{
    char string[] = "abcdefghijklmnopqrstuvwxyziii";    
    int  freqCount[ MAX_ALPHA ] = {0};

    charCounter(  string, freqCount );


    for( size_t i = 0; i < 26; i++)
    {
        printf("%c/%c     %d\n", (char)(i + 'A'), (char)(i + 'a'), freqCount[i]);
    }
}


void charCounter( char *string, int freqCount[] )
{
    for( size_t i=0; string[i]; i++ )
    {
        if( isalpha( string[i] ) )
        {
            freqCount[ toupper(string[i]) - 'A' ]++;
        }
    }
}

代码运行结果：

A/a     1
B/b     1
C/c     1
D/d     1
E/e     1
F/f     1
G/g     1
H/h     1
I/i     4
J/j     1
K/k     1
L/l     1
M/m     1
N/n     1
O/o     1
P/p     1
Q/q     1
R/r     1
S/s     1
T/t     1
U/u     1
V/v     1
W/w     1
X/x     1
Y/y     1
Z/z     1