我没有发现这方面的特别资料。
我试图找出一个函数，计算字符串中每个字符的出现次数，以便我可以在长度结束时将它们拉出来，以找出该字符串中使用了多少个同质字符。
我尝试过嵌套循环，第一个应用，第二个扫描字符串，如果它没有出现在字符串的其他地方，有条件地完成字符:
size_t CountUniqueCharacters(char *str)
{
int i,j;
char unique[CHAR_MAX];
for(i=strlen(str); i>=0; i--)
{
for(j=strlen(str); j>=0; j--)
{
if(str[i] != unique[j])
unique[j] = str[i];
}
}
return strlen(unique);
}
这个不能很好地工作。
如果您想限制某人输入惰性名称，如"aaaaaaaaaaaaa"，这是有用的。
下面是一个简单的c++解决方案。该方法复杂度为0 (n):
int countDistinct(string s)
{
unordered_map<char, int> m;
for (int i = 0; i < s.length(); i++) {
m[s[i]]++;
}
return m.size();
}
此方法具有O(n^2)复杂性，但在O(n)中非常有可能(尽管更复杂)做到这一点。
int CountUniqueCharacters(char* str){
int count = 0;
for (int i = 0; i < strlen(str); i++){
bool appears = false;
for (int j = 0; j < i; j++){
if (str[j] == str[i]){
appears = true;
break;
}
}
if (!appears){
count++;
}
}
return count;
}
方法遍历字符串中的所有字符——对于每个字符，它检查该字符是否出现在前面的任何字符中。如果不是，则该字符是唯一的，计数递增。
我发现下面的方法计算不同的字符，非常简单和在O(n)。这里的逻辑是，只是遍历字符数组，对于每个字符让它的计数为1，即使它重复，只覆盖1的值。遍历完成后，只需对所有字符的出现次数求和即可。
int count_distinc_char(const char *a){
int c_arr[MAX_CHAR] = {0};
int i, count = 0;
for( i = 0; a[i] != ' '; i++){
c_arr[a[i] - 'a'] = 1;
}
for( i = 0; i < MAX_CHAR; i++){
count += c_arr[i];
}
return count;
}
您可以使用HashSet或unordered_set来实现此目的，但它的最坏情况时间复杂度为0 (N)。因此，最好使用256个内存位置的数组或arr[256]。这将在O(256)~ O(1)时间内给出所需的输出
如果您正在使用c++，这里有一个具有最佳时间复杂度的一行代码:
int numUniqeChars = std::unordered_set<char>(std::begin(str), std::end(str)).size();
创建一个链表，以存储在字符串中找到的字符及其出现次数，节点结构如下:
struct tagCharOccurence
{
char ch;
unsigned int iCount;
};
现在一个接一个地读取字符串中的所有字符，当你读取一个字符时，检查它是否存在于链表中，如果是，则增加其计数，如果在链表中没有找到字符，则插入一个新的节点，'ch'设置为读取字符，计数初始化为1。
通过这种方式，您将仅在单遍中获得每个字符的出现次数。现在，您可以使用链表将遇到的字符打印多少次
我只是在寻找Stack Overflow上的其他一些东西时遇到了这个问题。但我仍然发布了一个解决方案，可能对一些人有帮助:
这也用于在这里实现huffman conding。这里你需要知道每个字符的出现频率，所以比你需要的要多一点。
#include <climits>
const int UniqueSymbols = 1 << CHAR_BIT;
const char* SampleString = "this is an example for huffman encoding";
左移运算符将lhs(即1)CHAR_BIT向左移动，因此乘以2^8(在大多数计算机上)，即256，因为在UTF-8中有256个唯一的符号
在main中有
int main() {
// Build frequency table
int frequencies[UniqueSymbols] = {0};
const char* ptr = SampleString;
while (*ptr != ' ') {
++frequencies[*ptr++];
}
}
我发现它非常简单和有用。唯一的缺点是frequencies的大小在这里是256，唯一性只是检查哪个值是1。
该算法成本更低，速度更快。因为每次搜索都是在一个更小的字符串中完成的。它也不需要字符串之间的比较或"分割"。或"(列表或数组)"。
QString out = "";
QString str = "Does he not know that God sees?";
while (str.size() > 0) {
out += str[0];
str = str.replace(str[0],"",Qt::CaseInsensitive);
}
qDebug() << out << out.size();
"hntkwaG吗?"13
忽略不区分大小写，在字母之间使用。
QString out = "";
QString str = "Does he not know that God sees?";
while (str.size() > 0) {
out += str[0];
if(str.size() != 1)
out += ',';
str = str.replace(str[0],"");
}
qDebug() << out;
"D o, e,年代,h, n, t, k, w, a、G、D ?"
使用Qt对文件名进行自然排序这是计算唯一单词数的C程序的源代码。C程序成功编译并在Linux系统上运行
int i = 0, e, j, d, k, space = 0;
char a[50], b[15][20], c[15][20];
printf("Read a string:n");
fflush(stdin);
scanf("%[^n]s", a);
for (i = 0;a[i] != ' ';i++) //loop to count no of words
{
if (a[i] = = ' ')
space++;
}
i = 0;
for (j = 0;j<(space + 1);i++, j++) //loop to store each word into an 2D array
{
k = 0;
while (a[i] != ' ')
{
if (a[i] == ' ')
{
break;
}
else
{
b[j][k++] = a[i];
i++;
}
}
b[j][k] = ' ';
}
i = 0;
strcpy(c[i], b[i]);
for (e = 1;e <= j;e++) //loop to check whether the string is already present in the 2D array or not
{
for (d = 0;d <= i;d++)
{
if (strcmp(c[i], b[e]) == 0)
break;
else
{
i++;
strcpy(c[i], b[e]);
break;
}
}
}
printf("nNumber of unique words in %s are:%d", a, i);
return 0;