精华内容
下载资源
问答
  • 从一篇txt文档中读取出英文单词统计不同英文单词出现的次数(大小写统一被视为小写),按照次数从多到少输出到另一txt文件中.
  • 使用C++双向列表统计文章单词出现频率,其中双向列表模仿STL中的List.
  • 原创C语言实现词频统计,使用通用数据类型的双向链表进行缓存,自动拆分单词,,可通过命令行一次性读取多文本,分别输出统计结果,简单实用。
  • 使用单链表统计英文文本单词个数

    千次阅读 2017-11-17 23:06:16
    #include "stdio.h" #include "malloc.h" #include "string.h" /** * 注意下面三个*********************************************...//统计字符串中单词个数及每个单词出现次数 typedef struct WordsNode{ int tim
    #include "stdio.h" 
    #include "malloc.h"
    #include "string.h"
    /**
    *		因为扫描的过程需要往线性表中增加数据,所以使用单链表的形式,减少移动 
    *		
    *		注意下面三个*********************************************中的内容
    * 		都是容易出错的地方! 
    */ 
    
    //统计字符串中单词个数及每个单词出现次数
    typedef struct WordsNode{
    	int time;
    	char s[20];//单词,最长长度为20 
    	WordsNode *next; 
    }WList; 
    
    	
    //将单词插入到带头节点的递增顺序排列的单链表中 
    WList *function(char word[],WList *list){
    	WordsNode *p=list->next,*pre=list;;
    	while(p&&strcmp(p->s,word)<0){
    		pre=p;
    		p=p->next;
    	}
    	if(p==NULL || strcmp(p->s,word)){
    		WordsNode *node=(WList *)malloc(sizeof (WordsNode));
    		node->time=1;
    		strcpy(node->s,word);//***********字符串不能直接赋值,需要拷贝或者手动遍历赋值!!!*************** 
    		node->next=pre->next;
    		pre->next=node;
    	}else if(strcmp(p->s,word)==0){
    		p->time=p->time+1;
    	}
    	return list; 
    }
    
    //扫面文章字符串,生成递增的单链表 
    WList *create(char *text){
    	WList *list=(WList *)malloc(sizeof (WordsNode));//头结点 
    	list->next=0;
    	int i=0,j=0;
    	char c=text[i];
    	char word[20];
    	while(c!='\0'){
    		if((c>='A'&&c<='Z') || c>='a'&&c<='z'){
    			word[j]=c;
    			j++;
    		}else{
    			if(j>0){
    				word[j]='\0';//******************字符结束标志!!!************************
    				list=function(word,list);
    				j=0;
    			}
    		}
    		i++;//***************************不要忘记递增!!!最好循环开始的时候就写好********************************* 
    		c=text[i];	
    	}
    	return list;
    }
    
    void print(WList *list){
    	WordsNode *p=list->next;
    	while(p) {
    		printf("%10s	:%10d次\n",p->s,p->time);
    		p=p->next;
    	}
    }
    
    int main(){
    	char s[300]="If the public can be well educated to enhance their awareness over the benefits of promoting Chinese culture | preserving the living circumstance | promoting the phenomenon mentioned, it would be much better.";
    	WList *list=create(s);
    	print(list);
    }
    

    
    
    展开全文
  • ,这函数包括了打开文件并显示里面的内容,将英文文章存放到链表的功能(此时因为考虑到文章中会含有标点符号,调用去标点的成员函数去掉标点,因此链表结点中的单词是纯单词,不含标点符号,调用结束后会返回纯...
  • 统计文本中各英文单词出现次数,并按词频逆序排列。 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <string.h> #include <stdlib.h> #include <ctype.h> #define SIZE 50 ...

    统计文本中各英文单词出现次数,并按词频逆序排列。

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <ctype.h>
    
    #define SIZE 50
    
    typedef struct words
    {
    	char str[SIZE];	//单词最长100个
    	int count;
    	struct words *next;
    }Words;
    
    
    // 初始化链表
    Words* InitWord()
    {
    	Words *headWord = (Words*)malloc(sizeof(Words));
    	strcpy(headWord->str,"");
    	headWord->count = 0;
    	headWord->next = NULL;
    	return headWord;
    }
    
    // 增加新单词
    void AddWord(Words *headWord,const char *str)//头插入
    {
    	Words *pos = headWord->next;	//储存当前第一个结构体的指针
    	Words *newWord = (Words*)malloc(sizeof(Words));
    	strcpy(newWord->str,str);
    	headWord->next = newWord;
    	if(pos == NULL)	newWord->next = NULL;//第一个单词,储存在链表尾部,next指向空
    	else			newWord->next = pos;
    	newWord->count=1;
    }
    
    int CheckStr(Words *headWord,const char *str)//检查单词是否出现过,若出现单词数量加一,返回1,没出现返回0
    {
    	Words *p = headWord->next;
    	if(headWord->next == NULL)	
    		{
    			AddWord(headWord,str);
    			return 1;
    		}
    	while(strcmp(p->str,str) != 0)
    	{
    		p = p->next;
    		if(p == NULL)	break;
    	}
    	if(p == NULL)	return 0;//没有该单词,返回0标记
    	else
    	{
    		++(p->count);	//已有单词,数量加一
    		return 1;
    	}
    	return -1;			//异常出错
    }
    
    // 读单词,该函数每次读取一个单词
    int ReadWord(FILE *fp,int *plen,char *str)
    {
    	fseek(fp, *plen, SEEK_SET);
    	unsigned char ch;
    	//if( feof(fp) )	//文件结束
     //   { 
     //       return 0;
     //   }
    	int flg_eof = 0;
    	int i=0;		// i 表示index
    	while(fread(&ch,sizeof(char),1,fp) != 0)	//注:isalpha(unsigned(ch)),需要强制转换
    	{
    		if(!isalpha(unsigned(ch)) && i == 0)	continue;//排除单词 不是字母 无法读取问题
    		if(isalpha(unsigned(ch)) || ch == '\'')//类似I'm中的 ' 符号,有且只能有一个
    		{
    			flg_eof = 1;	// 标记是否读过单词
    			str[i++] = ch;
    		}
    		else
    		{
    			break;
    		}
    	}
    	if(flg_eof == 0)	return 0;	//没有读文件,文件结尾了
    	str[i] = '\0';
    	*plen = ftell(fp);	// 对于文件首的偏移字节数
    	return *plen;
    }
    
    // 读取文件,调用“读取单词函数”,每读取一个单词检查是否需要 添加新单词 或 计数+1
    void ReadFile(Words *headWord,char *name)//文件操作,从文件中读取单词
    {
    	FILE *fp ;
    	int len = 0;		//标记文件指针在文件中的位置
    	if((fp= fopen(name,"r")) == NULL)
    	{
    		fp = fopen(name, "w+");/* 如果创建失败,新建一个文件  w+:可读写
    					文件存在则文件长度清为零,文件不存在时创建一个   */
    	}
    
    	char str[SIZE];
    	while(ReadWord(fp,&len,str) != 0)//fscanf(fp,"%s",str) != EOF
    	{
    		if(CheckStr(headWord,str) == 0)	//没有该单词,新增一个
    		{
    			AddWord(headWord,str);
    		}	
    
    	}
    
    	fclose(fp);
    }
    
    //单词交换顺序
    void SwapWord(Words *posWord,Words *posNext)
    {
    	// 交换单词
    	char tmpWord[SIZE]="";
    	strcpy(tmpWord ,posWord->str);  
    	strcpy(posWord->str, posNext->str);
    	strcpy(posNext->str, tmpWord);
    
    	// 交换对应单词计数
    	int tmpCount;
    	tmpCount	   = posWord->count;
    	posWord->count = posNext->count;
    	posNext->count = tmpCount;
    
    }
    // 单词排序,按计数从大到小
    void WordsSort(Words *headWord)
    {
    	if(headWord->next == NULL)	return;
    	Words *flg_word = NULL;
    	int flag;
    	while(flg_word != headWord->next)
    	{
    		flag = 0;
    		Words *pos = headWord->next;
    		Words *pos_next = pos->next;
    
    		while(pos_next != NULL)
    		{
    			if(pos->count < pos_next->count)
    			{
    				SwapWord(pos,pos_next);
    				flag = 1;
    			}
    
    			if(pos_next->next == flg_word)	//仿冒泡的i<n-i-1. 相当于flg_word每次减一
    			{
    				flg_word = pos_next;
    				break;	//可有可无,while中已有条件
    			}
    			pos = pos->next;
    			pos_next = pos_next->next;
    
    		}
    		if(flag == 0)	break;
    	}
    
    }
    
    // 打印词频排行榜
    void PrintWords(Words *headWord,const char *name)
    {
    	Words *pMove = headWord->next;
    	if(headWord->next == NULL)	return;
    	int count = 0;
    	printf("\t<<%s>>中出现的最高频率的单词:\n",name);
    	printf("\t单词:\t\t\t\t\t\t出现次数:\n");
    	while(pMove != NULL && count<200)
    	{
    		printf("\t%-50s%d\n",pMove->str,pMove->count);
    		pMove = pMove->next;
    		count++;
    	}
    	printf("\n");
    }
    
    //释放链表
    void free_Word(Words* headNode)
    {
    	Words *point = NULL;
    	while(headNode != NULL)
    	{
    		point = headNode;//指向所释放的空间
    		headNode = headNode->next;//指针后移
    		free(point);
    	}
    }
    
    
    
    int main()
    {
    	Words *headWord = InitWord();		//初始化链表,创建表头
    	char bookName[][100] = {"小王子.txt","CountWords.cpp","test.txt","Harry Potter and The Half-Blood Prince.txt" };
    										//当前文件*.cpp文件    //哈利波特
    	ReadFile(headWord,bookName[0]);		//文件操作
    	WordsSort(headWord);				//排序
    	PrintWords(headWord,bookName[0]);	//打印
    	free_Word(headWord);				//释放链表
    	return 0;
    }
    
    
    

    在这里插入图片描述


    文件下载:
    小王子.txt
    链接:https://wwa.lanzous.com/icWhOe8z34j
    Harry Potter and The Half-Blood Prince.txt
    链接:https://wwa.lanzous.com/inix8e8z33i

    展开全文
  • 除去重复后的单词个数(即重复的单词按1个计): " endl; Word ** wdarr = new Word*[size - delsum]; Inputp(wdarr); Sort(wdarr, 0 , size - delsum - 1 ); Show(wdarr, size - delsum); delete ...
    #include<iostream>
    #include<fstream>
    #include<string>
    
    using namespace std;
    
    struct Word       //定义结构体
    {
        string word;
        size_t length;
        Word* next;
        int repnum;//repeat number 重复次数
        bool ifdel;//if delete 是否被删除
        Word(string _word, size_t _lendth = 0, Word* _next = NULL, int _repnum = 1, bool _ifdel = false) :
            word(_word), length(_lendth), next(_next), repnum(_repnum), ifdel(_ifdel){}
    };
    
    Word *head = NULL, *tail = NULL;
    int size = 0;  //链表长度,即单词总个数
    int delsum = 0;//delete sum 被删除的总个数
    
    void Push(const string& str, const size_t& len)   //形成链表
    {
        if (NULL == head)
        {
            head = tail = new Word(str, len, NULL, 1, false);
        }
        else
        {
            tail->next = new Word(str, len, NULL, 1, false);
            tail = tail->next;
        }
        size++;
    }
    
    void Destory()   //delete new
    {
        Word* ptr = head;
        while (ptr)
        {
            Word* pt = ptr;
            ptr = ptr->next;
            delete pt;
        }
        head = tail = NULL;
        size = 0;
    }
    
    void Readin(string& mystr)   //read in  读入
    {
        string temps;
        for (size_t i = 0; i < mystr.length(); i++)
        {
            if (mystr[i] >= 'a'&&mystr[i] <= 'z' || mystr[i] >= 'A'&&mystr[i] <= 'Z')
            {
                temps += mystr[i];
            }
            else
            {
                if (!temps.empty())//不空的时候返回0
                {
    
                    Push(temps, temps.length());
                    temps.erase(temps.begin(), temps.end());
                }
            }
        }
    }
    void DeSame()      //delete the same 删除相同的单词(不是真删,只是做标记)
    {
        Word* p = head;
        while (p&&p->next)
        {
            while (p->ifdel&&p->next)
            {
                p = p->next;
            }
            Word* pt = p->next;
            while (pt)
            {
                if (!pt->ifdel&&pt->word == p->word)
                {
                    p->repnum++;
                    pt->ifdel = true;
                    delsum++;
                }
                pt = pt->next;
            }
            p = p->next;
        }
    }
    
    void Inputp(Word* warr[])   //input point 将未被“删除”的结点的指针传入数组
    {
        int i = 0;
        Word* pt = head;
        while (pt)
        {
            if (!pt->ifdel)
            {
                warr[i] = pt;
                i++;
            }
            pt = pt->next;
        }
    }
    
    void Sort(Word** warr, int start, int end)   //将指针按其指向的结点的repnum从大到小排序,快排实现
    {
        int i = 0, j = 0;
        Word* key = NULL;
        key = warr[start];
        i = start;
        j = end;
        while (i<j)
        {
            while (warr[j]->repnum <= key->repnum&&i<j)j--;
            warr[i] = warr[j];
            while (warr[i]->repnum >= key->repnum&&i<j)i++;
            warr[j] = warr[i];
        }
        warr[i] = key;
        if (i - 1>start)Sort(warr, start, i - 1);
        if (end > i + 1)Sort(warr, i + 1, end);
    }
    
    void Show(Word** warr, int len)
    {
        for (int i = 0; i < len; i++)
        {
            cout << warr[i]->word << "  " << warr[i]->repnum << endl;
        }
    }
    
    int main()
    {
        ifstream readfile("zpc.txt", ios::in);
        if (!readfile){ cout << "程序出现异常,自动退出!" << endl; return 0; }
        string str, str1;
        while (!readfile.eof())
        {
            getline(readfile, str1);
            str += str1;
            str += ' ';
        }
        readfile.close();
        Readin(str);
        DeSame();
        cout << "单词总个数(不考虑重复):" << size << endl;
        cout << "除去重复后的单词个数(即重复的单词按1个计):" << size - delsum << endl;
        Word** wdarr = new Word*[size - delsum];
        Inputp(wdarr);
        Sort(wdarr, 0, size - delsum - 1);
        Show(wdarr, size - delsum);
        delete[]wdarr;
        Destory();
        return 0;
    }

     

    转载于:https://www.cnblogs.com/zpcdbky/p/4432428.html

    展开全文
  • 统计文件中的单词个数并输出(C语言) 分析:用单链表存储单词和单词的个数,从文件中读出一个单词,判断单词是否是第一次出现,如果是第一次出现就创建结点插入链表后,否则该单词数+1。 #include <stdio.h> ...

    统计文件中的单词个数并输出(C语言)

    分析:用单链表存储单词和单词的个数,从文件中读出一个单词,判断单词是否是第一次出现,如果是第一次出现就创建结点插入链表后,否则该单词数+1。

    #include <stdio.h>
    #include <ctype.h>
    #include <stdlib.h>
    #include <string.h>
    typedef struct node
    {
    	char c[30];
    	int count;
    	struct node *next;
    }node,*link;
    
    node *firstWord(node *head,char word[])//判断单词是不是第一次出现
    {
    	node *p=head;
    	while(p->next != NULL)
    	{
    		if(strcmp(p->next->c, word) == 0)
    			return p->next;
    		p=p->next;
    	}
    	return NULL;
    }
    
    void print(node *p)//输出单词和次数
    {
    	node *q=NULL;
    	while(p->next != NULL)
    	{
    		printf("%s %d\n", p->next->c,p->next->count);
    		q=p;
    		p=p->next;
    		free(q);
    	}
    	free(p);
    }
    int main()
    {
    	FILE *fp;
    	node *head,*p,*q,*t;
    	int i;
    	char ch,word[30]={0};
    	head=(link)malloc(sizeof(node));
    	head->next=NULL;
    	p=head;
    	if((fp=fopen("word.txt","r")) == NULL)
    	{
    		printf("cannot open the file\n");
    		exit(0);
    	}
    	while((ch=fgetc(fp)) != EOF)
    	{
    		if(!isalpha(ch))
    			continue;
    		i=0;
    		while(isalpha(ch))
    		{
    			word[i++]=ch;
    			ch=fgetc(fp);
    		}
    		word[i]='\0';//加入结束符
    		t=firstWord(head,word);
    		if(t == NULL)//第一次出现的单词
    		{
    			q=(link)malloc(sizeof(node));
    			q->next=NULL;
    			q->count=1;
    			strcpy(q->c,word);
    			p->next=q;
    			p=q;
    		}
    		else
    			t->count++;
    	}
    	fclose(fp);
    	print(head);
    	return 0;
    }
    
    展开全文
  • 一、前言在之前写过一词频统计的C语言课设,别人说你一大三的怎么写C语言课程,我只想说我是先学习VB,VB是我编程语言的开始,然后接触到C语言及C++;再后来我是学习C++,然后反过来学习C语言,记得那时候自己在...
  • } } /// /// 该类是一个链表,使用键/值结构来存储 notEligibleQuery 查询出来的字符及其在数据源中的索引/// /// 键的类型/// 值的类型class Repostory where K : Integer { private K _key; public K Key { get {...
  • 本文实例为大家分享了JS 列出所有单词及其出现次数的实现代码,JS统计英语单词出现次数,可以调用LinkedList 类的方法orderInsert(), 以字母大小的顺序储存 英文字符串,同时记录英文单词出现的次数,供大家参考,...
  • 删除的最大问题就是怕删了一节点后它的后代们就悬空了,这时候肯定要从后代中找一优秀的后代来继承爸爸爷爷太爷爷的位置。 我们知道一节点的左子树是比老爸小的,右子树是比老爸大的,所以把删除节点的左...
  • php实现单词统计功能

    2021-03-29 08:08:40
    具体内容如下程序开始运行, 按"浏览"钮选择一英文文档, 再按"统计 Statistics"钮, 即可得到按字母顺序列出的所有单词,及其出现的次数用于测试的数据文档: data.txt驱动程序:word.phpoutput.php 和 ...
  • .python统计文本中每个单词出现的次数:#coding=utf-8__author__ = 'zcg'import collectionsimport oswith open('abc.txt') as file1:#打开文本文件str1=file1.read().split(' ')#将文章按照空格划分开print "原文本...
  • C语言实现从文件读取单词并且统计单词数我是一不喜欢写注释的Up 我是一不喜欢写注释的Up #include <iostream> #include<io.h> using namespace std; typedef struct { char str[256]; int count...
  • 利用这个链表统计一篇文章的不同词,针对不同单词和同一单词的不同拼写形式进行排序 本文利用了C语言来实现了一通用的双向链表,其中双向链表的实现借鉴了 实现通用的双向链表(c语言实现) 读李先静《系统...
  • 现需要统计若干段文字(英文)中的不同单词数量。 如果不同的单词数量不超过10,则将所有单词输出(按字母顺序),否则输出前10个单词。 注1:单词之间以空格(1或多空格)为间隔。 注2:忽略空行或者空格行。 注3:...
  • 问题描述:python 统计单词平均长度,统计a出现的次数有一txt文件叫123.txt,里面是很多很多单词我想统计这些单词的平均长度,然后找出a出现的次数请根据这框架写code,包括之前怎样打开那个txt文件def average_...
  • 现有一片英语短文,要求用c语言实现对该文章的词频统计,即利用文件读写方法,提取文本中的每一个单词之后通过算法统计其出现频率,并输出到另外的文件中。 短文如下: Of all the changes that have taken place ...
  • 1. 统计的对象words.txt,每个单词占一行(从简考虑了~)zjd@ubuntu:~/test$ cat word.txtusedthiscountmysqlcountthisusedmysqllinuxthisredisappleandroidredisapple2. 统计个单词的频率方法1:zjd@ubuntu:~/test$...
  • I have a file that contains a city name and then a state name per line in the file. I am suppose to count how many times a state name occurs and return the value.for example, if my file contained:Los ...
  • c++,背单词系统 链表

    2021-03-16 08:51:00
    单词系统, 可以分为管理员和学员,管理员增加单词,学员背诵单词,可以统计那些单词没背过。基于结构体和链表实现,适合新手学习链表。管理员密码为112233
  • 统计各字母在文本中出现的次数 #include<stdio.h> #include<stdlib.h> #include<string.h> struct word{ char word[200]; int num; struct Sword * next; }; typedef struct word Word; void ...
  • 四道大题的第一题就是单词统计程序的设计思想;为了记住这一天,我打算今天通过代码实现一下;我将用到的核心数据结构是二叉树;(要是想了解简单二叉树的实现,可以参考我的另一篇文章:...
  • 哈希表在查找方面有非常大应用价值,本文记录一下利用哈希散列表来统计文本文件中每个单词出现的重复次数,这需求当然用NLP技术也很容易实现。一、基本介绍1、Hash Key值:将每个单词按照字母组成通过一乘子循环...
  • 链表实现从文件中读取和统计单词,该法应当还要添加文件读取方式
  • 具体代码如下所述:#...//num 用来统计单词的个数//state 用来记录程序当前是否处于一个单词之中,初值为0,表示不在单词中,值为1,表示正处于在一个单词中printf("Please input the number of lines for Engli...
  • 统计英文article.txt文件中出现hello这个单词的次数这是article.txt文件内容 {hello The Royal Navy is trying hello to play hello down the problem,after first trying to hide it. It is clearly embarrassing...
  • 用C语言写的统计英文文章单词的源程序,注释清楚,代码简洁,主要用链表结构实现,能够正确运行,里面统计时把数字和其他字母等也统计为一个单词,可以在统计的方法里面进行修改,方便学习参考
  • 多种方式实现英文单词词频统计和检索系统

    千次阅读 多人点赞 2020-03-01 22:01:47
    一、课程设计的目的 1、掌握数据结构课程的基本内容和方法。...一篇英文文章存储在一文本文件中,分别基于线性表、二叉排序树和散列表的不同存储结构,实现单词词频的的统计单词的检索功能。同时计算不同检索...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,181
精华内容 4,472
关键字:

统计链表单词个数