使用链表进行统计不重复单词的个数（因为这样生成的不会浪费资源，而且不会造成过多的内存碎片）
思路：一个字母一个字母的读取文章中的内容，然后进行判断，读取完一个单词之后再进行和前面的不重复单词遍历对比查看有没有相同的，有的话则不申请新的节点，继续使用之前的进行覆盖，没有的话则正常申请新的节点进行存取
存取完之后就是排序，使用冒泡法排序，排序是对链表的指向进行改变
然后打印
释放内存空间
代码如下：
main.h ：
include"find_ten_frequent.h"
extern Rec_word *rec_word;
extern int nList_Len;
int main()
{
FILE *fp;
char filename[30];
Rec_word *Print;
Rec_word *Delete;
rec_word = (Rec_word *)malloc(sizeof(Rec_word));
if(rec_word == NULL)
return 0;
printf("请输入您要导入的文件名字（请附上绝对地址,如：D:/topic.txt）\n");
scanf("%s", filename);
fp = fopen(filename, "r"); //文件来源
if(fp == NULL)
{
perror("打开文件失败");
return 0;
}
rec_word = Create_Rec_Word(fp);
Sort_List(rec_word); //排序
Print_List(rec_word); //打印链表
Release_Space(rec_word); //释放内存空间
fclose(fp);
return 0;
}
find_ten_frequent.c:
include"find_ten_frequent.h"
int nList_Len=0; //统计链表的长度
extern Rec_word rec_word;
/两个数组进行比较
**传入值：需要比较的两个数组
**返回值：1.相同 0.不相同
*/
int Compare(Rec_word *a, Rec_word *b)
{
int i; //循环计数使用
if(a->nlength != b->nlength)
return 0;
for(i=0;i<a->nlength;i++)
{
if(a->word[i] != b->word[i])
return 0;
}
return 1;
}
/*创建接收所有不重复单词的列表
**返回值：返回头指针
/
Rec_word Create_Rec_Word(FILE *fp)
{
int bBianli = FALSE ; //判断你是否需要进行遍历查找有没有相同字母 1.需要 0.不需要
int bInc_List = FALSE; //判断是否允许增加节点 1. 允许 0.不允许
int bNeed_Realloc = FALSE; //标志有没有需不需要重新申请节点数据（单词）的内存， 1. 需要 0.不需要
int bRec_A_Word = FALSE; //标记是否接收完了一个单词
int bSame_Word = FALSE; //用来标记是否有相同的字母： 1. 有 0. 没有
int bNum = FALSE; //判断是否是一个纯数字 1.是纯数字 0.不是纯数字
int nAword_Len=0; //接收一个单词的长度
int z, k; //用于循环的次数统计
char ch;
Rec_word *Head, *H; //H使用的是Head的地址
Rec_word *temp; //插入的节点
Rec_word *Find; //用于链表的遍历查找
char cTemp_Word[50]; //用来临时接收单词
Head = (Rec_word )malloc(sizeof(Rec_word));
if(Head == NULL)
return 0;
H = Head;
H->next = NULL;
temp = (Rec_word)malloc(sizeof(Rec_word));
if(temp == NULL)
return 0;
temp->next = NULL;
do
{
ch = fgetc(fp);
printf("%c", ch); //打印文本
if(( ('a' <= ch) && (ch <= 'z'))|| ( ('A' <= ch) && (ch <= 'Z')) || (ch == '/') || (ch == '-')|| (ch == '&') || (ch =='\'') || (ch<='9'&&ch>='0'))
{
cTemp_Word[nAword_Len] = ch; //临时接收单词
nAword_Len++;
bRec_A_Word = TRUE;
}
else if(bRec_A_Word) //接收到了一个单词
{
bBianli = TRUE; //允许遍历
bInc_List = TRUE; //允许增加链表节点
/*判断是否是纯数字*/
for(z=0;z<nAword_Len;z++)
{
if( cTemp_Word[z] < '0' || cTemp_Word[z] > '9')
break;
}
if(z == nAword_Len)
bNum = TRUE; //纯数字
else
bNum = FALSE; //非纯数字
/*****************************************/
temp->num = 1; //初始化次数为1
temp->nlength = nAword_Len;
bRec_A_Word = FALSE; //开始统计下一个单词
if(bNeed_Realloc) //这里需要申请比字符串数字多一个空间，用来存储结束符
{
temp->word = (char *)realloc(temp->word,sizeof(char)*(nAword_Len+1)); //因为原本已经申请了，所以只需要进行扩大或者压缩重新申请即可
if(temp->word==NULL)
return 0;
bNeed_Realloc = FALSE;
}
else
{
temp->word = (char *)malloc(sizeof(char)*(nAword_Len+1)); //新的申请一个内存
if(temp->word==NULL)
return 0;
}
/*给链表节点的指针赋值*/
for(z=0; z<nAword_Len; z++)
{
temp->word[z] = cTemp_Word[z]; //将接收到的单词赋值过来
}
temp->word[z] = '\0'; //加入一个字符串结束符否则后面会是乱码
nAword_Len = 0;
}
if(bBianli) //统计完一个单词时
{
Find = Head->next;
while(Find != NULL)
{
if(Compare(Find, temp)) //比较是否相同
{
Find->num++;
bSame_Word = TRUE;
break;
}
else
bSame_Word = FALSE;
Find = Find->next;
}
bBianli = FALSE;
}
if(!bNum && !bSame_Word && bInc_List) //如果统计完一个单词并且不是纯数字还没有重复的则可以保存进行处理
{
// printf("改增加空间了\n");
H->next = temp;
H = temp;
nList_Len++;
temp = (Rec_word*)malloc(sizeof(Rec_word));
if(temp == NULL)
return 0;
temp->next = NULL;
bInc_List = FALSE;
}
else if( bNum || bSame_Word) //这个单词有问题，需要被覆盖
{
bNeed_Realloc = TRUE;
}
}while( !feof(fp));
printf("\n总共有%d个不重复的单词\n", nList_Len);
return Head;
}
/*排序函数
**从大到小进行排序
**传入的值：链表头指针
/
void Sort_List(Rec_word rec_word) //冒泡法，改变的只是链表的指向，所以不需要重新定义一个内存空间
{
Rec_word *Sort_Front;
Rec_word *Mid;
Rec_word *Sort_Rear;
int z, k; //用于循环判断
z = nList_Len;
if(rec_word == NULL)
return 0;
while( z > 1 ) //外循环是长度-1次
{
Sort_Front = rec_word;
Mid = rec_word->next;
Sort_Rear = Mid->next;
k = z;
z--;
while(k>1)
{
if(Mid->num < Sort_Rear->num)
{
Mid->next = Sort_Rear->next;
Sort_Front->next = Sort_Rear;
Sort_Rear->next = Mid; //这三个步骤执行完之后，会变成 front -> rear -> mid
Sort_Front = Sort_Rear; //指向下一个需要对比的两个节点,并保持front -> mid - >rear
Sort_Rear = Mid->next;
}
else
{
Sort_Front = Mid;
Mid = Sort_Rear;
Sort_Rear = Sort_Rear->next;
}
k--;
}
}
}
/打印链表/
void Print_List(Rec_word *H)
{
int z;
Rec_word *Print;
Print = H->next;
for(z = 0; z < 10 && z < nList_Len; z++)
{
printf("%s\t", Print->word);
printf("出现的次数是： %d\n", Print->num);
Print = Print->next;
}
}
/释放内存空间/
void Release_Space(Rec_word *Head)
{
Rec_word *Delete;
Delete = Head->next;
while(Delete != NULL)
{
if(Delete->word == NULL)
return 0;
//printf("删除啦\n");
free(Delete->word);
Delete = Delete->next;
}
if( rec_word != NULL)
{
free(rec_word);
//printf("完成啦\n");
}
}
find_ten_frequent.h:
ifndef FIND_TEN_FREQUENT_H
define FIND_TEN_FREQUENT_H
include<stdio.h>
include<string.h>
include<stdlib.h>
/结构体定义/
typedef struct tagREC_WORD
{
int num; //用来接收单词出现的次数
int nlength; //单词的长度
char *word; //用来接收单词
struct tagREC_WORD next;
}Rec_word;
Rec_word rec_word;
/宏定义/
define TRUE 1
define FALSE 0
/函数申明/
int Compare(Rec_word *, Rec_word );
Rec_word Create_Rec_Word(FILE *);
void Sort_List(Rec_word * );
void Release_Space(Rec_word *);
void Print_List(Rec_word *);
