Question

字符串处理的程序~

我有一堆字符串（很多），无规则排序，其中有相同的字符串。然后想按顺序统计每一个字符串出现的次数。Java或C++，C都可以。
比如这样一推字符串：abc，百度知道，__google ，%%%，abc，……
统计次数并排序。
我有一大堆数据啊，几万个字符串……(*^_^*)……

Answer 1

给你个可用的程序吧，我自己编的，你等等哈，今天之内就能给你答案了~~~
抓紧编程中....
已完工，给你代码：
//把要统计的字符串放入一个txt文件，命名为sources.txt，具体存放路径是：d:\sources.txt
//程序运行结束后，会在d盘生成一个save.txt文档，存放的是统计结果
//注：由于运行后弹出的程序窗口显示的内容有限，所以要查看统计结果请到d:\save.txt中查看
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 555
typedef struct LNode
{
int n;
char ch[MAX_SIZE];
struct LNode *next;
}LNode,*LinkList;
void ListCheck(LinkList L,LinkList newbase)
{
LinkList p=L,ps;
if(! L->next)//空表的时候
{
L->next=newbase;
return;
}
while(p=p->next)
{
if(! strcmp(p->ch,newbase->ch))
break;
ps=p;
}
if(! p)
ps->next=newbase;
else
p->n++;
}
void ListCreate(LinkList L,FILE *fp)
{
int i;
LinkList p,newbase;
p=L;
while(!feof(fp))
{
i=0;
newbase=(LinkList)malloc(sizeof(LNode));
newbase->n=1;
newbase->next=NULL;
newbase->ch[i]=fgetc(fp);

while( (newbase->ch[i] == ' ' || newbase->ch[i] == ',' || newbase->ch[i] == '\t' || newbase->ch[i] == '\n') && !feof(fp) )
newbase->ch[i]=fgetc(fp);//跳过无效字符

while(newbase->ch[i] != ' ' && newbase->ch[i] != ',' && newbase->ch[i] != '\t' && newbase->ch[i] != '\n' && !feof(fp))
{
++i;
newbase->ch[i]=fgetc(fp);
}
if(!i) break;//当文件最后为无效字符如空格时，i=0;
newbase->ch[i]='\0';
ListCheck(L,newbase);//检查当前字符串与表中储存的是否重复
}
}
void ListSort(LinkList L)
{
FILE *fp_save;
LinkList p,h;
if((fp_save=fopen("d:\\save.txt","w")) == NULL)
{
puts("cannot open this file!");
return 0;
}
while(1)
{
p=L->next;
h=p->next;
while(h)
if(p->n > h->n)
h=h->next;
else
{
p=h;
h=h->next;
}
if(p->n==0) break;
printf("@字符串:\n%s\t\t\t\t\n@出现次数: %d\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",p->ch,p->n);
fprintf(fp_save,"@字符串:\n%s\t\t\t\t\n@出现次数: %d\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",p->ch,p->n);
p->n=0;//置为最小，以继续查找最大值
}
fclose(fp_save);
}
void ListDestroy(LinkList L)
{
LinkList p;
while(p=L->next)
{
L->next=p->next;
free(p);
}
free(L);
}
int main()
{
FILE *fp;
LinkList L;
if((fp=fopen("d:\\sources.txt","r")) == NULL)
{
puts("cannot open this file!");
return 0;
}

L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;

ListCreate(L,fp);
ListSort(L);
ListDestroy(L);
fclose(fp);
return 0;
}

Answer 2

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

int main()
{
vector<string> vecStrTab;

vecStrTab.push_back("aaa");
vecStrTab.push_back("bbb");
vecStrTab.push_back("aaa");
vecStrTab.push_back("百度");
vecStrTab.push_back("百度");

if( vecStrTab.size() == 0 )
{
cout<<"there is no string!"<<endl;
return -1;
}

sort(vecStrTab.begin(),vecStrTab.end());

int iCount = 1;
string str = vecStrTab.at(0);
for(vector<string>::iterator iter = vecStrTab.begin()+1;
iter != vecStrTab.end();
++iter)
{
if( str == *iter)
{
iCount++;
}
else
{
cout<<"string: "<<str<<" have "<<iCount<<endl;
str = *iter;
iCount = 1;
}
}

// treat last one
if( iCount > 1)
{
cout<<"string: "<<str<<" have "<<iCount<<endl;
}

return 0;
}

Answer 3

。因为加上去以后输出第二行结果为5.
至于之前为什么为11.你应该发现了。实际上不存在a[5]这个单元。c++只是向后延续访问了一下。a数组没有没有一个'\0'作为结尾，c++只好按照自己的规则计算字符串长度。
具体规则我不清楚。

先看b的结果。当你给a数组赋值以后，i的值为5，不是4. 将c++访问到的a[5]单元的值（是随机值）带入到那个处理函数中，return '9'.当然就全是9了.

再来看a数组。根据c++的变量分配原则，b数组在a数组之前分配，a数组紧跟在b数组后面。而变量内存单元分配是以4字节的整数倍来分配的。你定义一个b、char类型，虽然看起来只用了一个字节，但是接下来的3个字节系统是不允许再分配给别的单元了。定义char num[5],看起来只有5个单元，但只接下来的3个字节也不允许再分配了，因为4<5<8。结合这些规则。我们可以画出a和b的内存分配图了。
a的首地址在从b的首地址开始向后的第八个位置。

下面进入cimapp循环，循环变量j的上限是10,记住。也就是做了11次。在b首字节开始，连续访问11个字节，你能看到，最后3个字节已经进入了a数组的领域了。就像b数组全是9一样，a的那3个字节也变成9了。

基本就是这个原理了。可能我没讲清楚，请指教！

哎。。。。我表述能力有限啊。。。。请谅解。。。

c++内存单元分配是以4个字节为一个整体。一个char类型的变量是一个字节，但是紧跟着的3个字节的空间是不允许再分配给其他的变量的。
如果你定义了char a[5]，那表面上c++分配了5个字节，但其实是用掉了8个字节。后面多出来的3个不允许再分配给其他的变量了。
b在a的前面。下面我描述一下内存分配图吧。一个O表示一个字节的单元：
| OOOO,OOOO | OOOO,OOOO |
b 0123 4567 a 0123 4567 序号为567的字节只表示顺序，数组其实不包含。

Answer 4

方法很简单，问题是效率。
实践证明用遍历的方法效率最高，只需要循环“几万-你要找的字符串长度” 次