C 查找字谜 if（strlen（a）！=strlen（b））{ printf（“非字谜”）； }否则{ 对于（int i=0；i

这是一个代码片段，用于检查两个字符串是否为字谜。这里如何处理重复字符？另外，这个程序是否可以更优化？这段代码的运行时复杂性是多少？

首先，这不是正确的解决方案。在这两个字符串中思考：“aabc”和“aade” a[0]==b[0]，a[0]==b[1]，a[1]==b[0]和a[1]==b[1]。len应该是4岁，但他们不是字谜。复杂性是O（n^2）是n字符串的长度

正如@Sulthan所回答的，更好的方法是对复杂度为O（n*log（n））的字符串进行排序，然后一次性比较两个字符串O（n）

要对O（n*log（n））中的字符串进行排序，不能使用冒泡方法，但可以使用如下所述的合并排序：

---

更好的方法是创建一个整数数组，其中计算第一个字符串中每个字符的出现次数，然后减去第二个数组中每个字符的出现次数。最后，辅助阵列的所有位置都必须为0。

首先，这不是正确的解决方案。在这两个字符串中思考：“aabc”和“aade” a[0]==b[0]，a[0]==b[1]，a[1]==b[0]和a[1]==b[1]。len应该是4岁，但他们不是字谜。复杂性是O（n^2）是n字符串的长度

正如@Sulthan所回答的，更好的方法是对复杂度为O（n*log（n））的字符串进行排序，然后一次性比较两个字符串O（n）

要对O（n*log（n））中的字符串进行排序，不能使用冒泡方法，但可以使用如下所述的合并排序：

---

更好的方法是创建一个整数数组，其中计算第一个字符串中每个字符的出现次数，然后减去第二个数组中每个字符的出现次数。最后，辅助数组的所有位置都必须为0。

最佳解决方案可能是计算每个字符串中的字符数，然后比较两个计数。理想情况下，我们应该使用字典数据结构，但为了简单起见，我将在数组上演示算法：

if (strlen(a) != strlen(b)) {
    printf("Not anagram");
} else {
    for (int i = 0; i < strlen(a); i++) {
        for (int j = 0; j < strlen(b); j++) {
            if (a[i] == b[j]) {
                len++;
            }
        }
    }
    if (len != strlen(a))
        printf("Not anagram");
    else
        printf("Anagram");
}
return 0;

char*word1=“word1”；
char*word2=“ordw1”；
//C字符串只能有256个可能的字符，因此让我们将计数存储在一个包含256项的数组中。
int*letterCounts1=calloc（256，sizeof（int））；
int*letterCounts2=calloc（256，sizeof（int））；
尺寸长度1=标准长度（字1）；
尺寸长度2=标准长度（字2）；
对于（尺寸i=0；i

该算法具有线性（

O（n）

）复杂性（在“字典”上的迭代可以被视为常数）

---

您的原始解决方案具有二次复杂性，但是，您还必须确保将

strlen

的结果存储到变量中，因为对

strlen

的每次调用都必须迭代整个字符串，将复杂性增加到立方。

最佳解决方案可能是计算每个字符串中的字符数，然后比较两个计数。理想情况下，我们应该使用字典数据结构，但为了简单起见，我将在数组上演示算法：

if (strlen(a) != strlen(b)) {
    printf("Not anagram");
} else {
    for (int i = 0; i < strlen(a); i++) {
        for (int j = 0; j < strlen(b); j++) {
            if (a[i] == b[j]) {
                len++;
            }
        }
    }
    if (len != strlen(a))
        printf("Not anagram");
    else
        printf("Anagram");
}
return 0;

char*word1=“word1”；
char*word2=“ordw1”；
//C字符串只能有256个可能的字符，因此让我们将计数存储在一个包含256项的数组中。
int*letterCounts1=calloc（256，sizeof（int））；
int*letterCounts2=calloc（256，sizeof（int））；
尺寸长度1=标准长度（字1）；
尺寸长度2=标准长度（字2）；
对于（尺寸i=0；i

该算法具有线性（

O（n）

）复杂性（在“字典”上的迭代可以被视为常数）

您的原始解决方案具有二次复杂性，但是，您还必须确保将

strlen

的结果存储到变量中，因为对

strlen

的每次调用都必须迭代整个字符串，将复杂性增加到三次方。

这里有一些答案：

• 您的算法不会处理重复的字母，它可能会返回误报
• 因为您没有发布包含所有声明和定义的完整函数定义，特别是

  len

  是否初始化为

  0

  ，所以不清楚它是否正确
• 如果编译器无法优化对

  strlen（）

  的大量冗余调用，则它具有O（N2）时间复杂度，甚至O（N3）

以下是针对具有线性复杂度的8位字符系统的简单解决方案：

char *word1 = "word1";
char *word2 = "ordw1";

// C strings can have only 256 possible characters, therefore let's store counts in an array with 256 items.
int* letterCounts1 = calloc(256, sizeof(int));
int* letterCounts2 = calloc(256, sizeof(int));
size_t length1 = strlen(word1);
size_t length2 = strlen(word2);

for (size_t i = 0; i < length1; i++) {
    int letterIndex = word1[i] & 0xFF;
    letterCounts1[letterIndex] += 1;
}

for (size_t i = 0; i < length2; i++) {
    int letterIndex = word2[i] & 0xFF;
    letterCounts2[letterIndex] += 1;
}

bool isAnagram = true;

for (size_t i = 0; i < 256; i++) {
    if (letterCounts1[i] != letterCounts2[i]) {
        isAnagram = false;
        break;
    }
}

free(letterCounts1);
free(letterCounts2);

if (isAnagram) {
    printf("Anagram");
} else {
    printf("Not anagram");
}

#包括
#包括
整数校验字符（常量字符*a，常量字符*b）{
大小计数器[256]；
尺寸长度=标准长度（a）；
尺寸i；
如果（len！=strlen（b））{