isalpha单词（c语言字符数组计算单词个数）

本文目录

• c语言字符数组计算单词个数
• c语言用到的单词
• C语言一些单词
• 输入一段英文，再输入一个单词，查找该单词在该段英文中出现的次数以及位置，位置信息保存在一个数组中急
• c++ 最长最短单词
• 如何用c语言的数据结构做一个英语词典,要求是:用二叉树,能实现建立词典,查找插入删除单词
• 给你一个字典，一段文字， 编个程序，输出文字里面所有的单词个数
• C语言如何将一个字符串中的单词分别存到另一个二维数组
• 找出一句话中最长的单词并打印

c语言字符数组计算单词个数

#include《stdio.h》
#include《ctype.h》
int main()
{ int i,n=0;
  char s;
  gets(s);
  for(i=0;s;i++)
    if(i==0||isspace(s))
  if(isalpha(s))n++;
  printf("%d\n",n);
  return 0;
}

c语言用到的单词

1.保留字：
C语言的关键字共有32个，根据关键字的作用，可分其为数据类型关键字、控制语句关键字、存储类型关键字和其它关键字四类。
（1）数据类型关键字（12个）：char, double, enum, float, int, long, short, signed, struct, union, unsigned, void
（2）控制语句关键字（12个）：break, case, continue, default, do, else, for, goto, if, return, switch, while
（3）存储类型关键字（4个）：auto, extern, register, static
（4）其它关键字（4个）：const, sizeof, typedef, volatile
2.控制语句：
控制语句完成一定的控制功能。C语言只有9条控制语句，又可细分为三种：
（ 1）选择结构控制语句
if()～else～, switch()～
（2）循环结构控制语句
do～while(), for()～, while()～, break, continue
（3）其它控制语句
goto, return
3。函数：

字符串函数
bcmp
bcopy
bzero
memccpy
memchr
memcmp
memcpy
memicmp
memmove
memset
movmem
setmem
stpcpy
strcat
strchr
strcmp
strcmpi
strcpy
strcspn
strdup
stricmp
strlen
strlwr
strncat
strncmp
strncmpi
strncpy
strnicmp
strpbrk
strrev
strset
strstr
strtok
strupr

数学函数
abs
acos
asin
atan
atan2
ceil
cos
cosh
exp
fabs
floor
fmod
frexp
hypot
ldexp
log
log10
modf
pow
pow10
sin
sinh
sqrt
tan
tanh

输入输出函数
getchar
kbhit
printf
putchar

系统库函数
ClearScreen
DispBCD
SetScrollBar
TextOut
UpdateLCD
bell
block
clrscr
cursor
delay
get_chi_font
get_eng_font
getkey
getpixel
gotoxy
line
move
noidle
outtextxy
putpixel
pyfc
rectangle
sleep
textmode
time
write_chi_font
write_eng_font

标准函数
exit
itoa

字符函数
isalnum
isalpha
iscntrl
isdigit
islower
isascii
isgraph
isprint
ispunct
isspace
isupper
isxdigit
toascii
tolower
toupper

动态内存分配函数
calloc
free
malloc
realloc

C语言一些单词

C语言常用单词 2009-02-04 16:14 算法 algorithm 机器语言machine language
运算与逻辑单元ALU 内存单元 memory unit
分析 analysis 微处理器microprocessor
应用软件application software 模型model
汇编程序assembler
面向对象的语言object-oriented language
汇编语言assembler language 操作码opcode
备份件backup copies 操作系统operating system
位bit
面向过程的语言procedure-oriented language
引导boot 程序设计progremming
字节bytes 汇编语言programming language
伪代码pseudocode 类class
细化refinement 编写代码coding
循环结构repetition 编译型语言compiled language
编译程序compiler 辅存secondary storage
计算机程序computer program 选择结构selection
控制单元 control unit 顺序结构sequence
文档编写documentation 软件software
软盘floppy diskette
软件开发过程software development procedure
流程图flowchart 软件工程software engineering
硬盘hard disk 软件维护software maintenance
硬件hardware 源代码soure code
高级语言high-level language 源程序source program
输入/输出单元 I/O unit 语法syntax
调用invocation 系统软件system software
循环结构iteration 测试testing
解释型语言interpreted language二进制补码two’s complement
解释程序interpreter 低级语言low-level language抽象abstraction 累加accumulating
参数argument 自减运算符decrement operator
算术运算符arithmetic operators 参数argument
赋值语句assignment statement 赋值运算符assignment operators
综合性associativity 类型转换cast
原子数据类型atomic data value 编译时错误compile-time error
字符值character values 记数counting
类class 对齐justificating
注释comments 逻辑错误logic error
数据类型data type 左值lvalue
声明语句declaration statement 魔术数magic number
定义语句definition statement 数学头文件mathematical library
双精度数double-precision number 八进制octal
转义序列escape sequence 已命名常数named constant
表达式expression 桌面检查desk checking
浮点数floating-point number 域宽操纵符field width manipulator
函数function 回显打印echo printing
头文件header file 十六进制hexadecimal
标识符identifier
程序验证与测试program verification and testing
整数值iteger value 自增运算符 increment operator
关键字keyword 实现implement
操纵符manipulator 提示prompt
混合表达式mixed-mode expression 运行时错误run-time error
助记符mnemonic 右值rvalue
模块module 符号常数symbolic constant
取模运算符modulus operator 语法错误syntax error
优先级 preccedence 跟踪tracing
变量variable 类型转换type conversions 1.保留字：
C语言的关键字共有32个，根据关键字的作用，可分其为数据类型关键字、控制语句关键字、存储类型关键字和其它关键字四类。
（1）数据类型关键字（12个）：char, double, enum, float, int, long, short, signed, struct, union, unsigned, void
（2）控制语句关键字（12个）：break, case, continue, default, do, else, for, goto, if, return, switch, while
（3）存储类型关键字（4个）：auto, extern, register, static
（4）其它关键字（4个）：const, sizeof, typedef, volatile
2.控制语句：
控制语句完成一定的控制功能。C语言只有9条控制语句，又可细分为三种：
（ 1）选择结构控制语句
if()～else～, switch()～
（2）循环结构控制语句
do～while(), for()～, while()～, break, continue
（3）其它控制语句
goto, return
3。函数：

字符串函数
bcmp
bcopy
bzero
memccpy
memchr
memcmp
memcpy
memicmp
memmove
memset
movmem
setmem
stpcpy
strcat
strchr
strcmp
strcmpi
strcpy
strcspn
strdup
stricmp
strlen
strlwr
strncat
strncmp
strncmpi
strncpy
strnicmp
strpbrk
strrev
strset
strstr
strtok
strupr
数学函数
abs
acos
asin
atan
atan2
ceil
cos
cosh
exp
fabs
floor
fmod
frexp
hypot
ldexp
log
log10
modf
pow
pow10
sin
sinh
sqrt
tan
tanh
输入输出函数
getchar
kbhit
printf
putchar
系统库函数
ClearScreen
DispBCD
SetScrollBar
TextOut
UpdateLCD
bell
block
clrscr
cursor
delay
get_chi_font
get_eng_font
getkey
getpixel
gotoxy
line
move
noidle
outtextxy
putpixel
pyfc
rectangle
sleep
textmode
time
write_chi_font
write_eng_font
标准函数
exit
itoa
字符函数
isalnum
isalpha
iscntrl
isdigit
islower
isascii
isgraph
isprint
ispunct
isspace
isupper
isxdigit
toascii
tolower
toupper
动态内存分配函数
calloc
free
malloc
realloc 读音要有一定的英语基础...基本上到4级...下个金山词霸或着有道...也有一定帮助！

输入一段英文，再输入一个单词，查找该单词在该段英文中出现的次数以及位置，位置信息保存在一个数组中急

看上去有点长，做了一些修饰性的东西。
#include 《stdio.h》
#include 《string.h》
#include 《ctype.h》
#define M 100
#define N 10
#define T 10
int main(void)
{
int a={0};
int i,j=0,k=0,num=0,word=0;
char str,*p;
printf("输入一行英文：\n");
gets(str);
printf("输入一个单词：\n");
gets(str1);
p=str;
while(!isalpha(*p)) p++; //去掉句子前的其他字符
for(i=0;*(p+i)!=’\0’;i++)
if(isalpha(*(p+i)))
{
if(word==0)
{
word=1;
num++;
}
str2=*(p+i);
}
else
{
word=0;
str2=’\0’;
if(strcmp(str1,str2)==0) a=num;
j=0;
}
str2=’\0’;
if(strcmp(str1,str2)==0) a=num; //处理句子最后一个单词
printf("结果：\n");
printf("这句共有单词%d个\n",num);
if(k==0)
printf("句子中没有单词%s\n",str1);
else
{
printf("所查单词位置：\n");
for(i=0;i《k;i++)
printf("%3d",a);
}
getchar();
}

显示样式：
输入一行英文：
i am a boy.he is a boy.
输入一个单词：
boy
结果：
这句共有单词8个
所查单词位置：
4 8

c++ 最长最短单词

修改后的源代码：

#include《iostream》
using namespace std ;
char line ;
int main()
{
    cin.getline(line,20000) ;
    int cur = 0, pos = 0, maxlen = 0, minlen = 20000 ;
    int minpos, maxpos ;
    int len = strlen(line) ;
    for (int i = 0; i 《 len; i++) {
        if (isalpha(line)) cur ++ ;
        else {
            if (cur 》 maxlen) {
                maxlen = cur; maxpos = pos ;
            }
            if (cur 《 minlen) {
                minlen = cur; minpos = pos ;
            }
            cur = 0; pos = i + 1 ;
        }
    }
    if (cur 》 maxlen) {
        maxlen = cur; maxpos = pos ;
    }
    if (cur 《 minlen) {
        minlen = cur; minpos = pos ;
    }
    if (minlen == maxlen) {
        for (int i = minpos; isalpha(line); i ++)
            cout 《《 line ;
    } else {
        for (int i = maxpos; isalpha(line); i ++)
            cout 《《 line ;
        cout 《《 endl ;
        for (int i = minpos; isalpha(line); i ++)
            cout 《《 line ;
        cout 《《 endl ;
    }
    return 0;
}

isalpha()为判断该字符是否为大写或小写字母，返回bool值，1或0

1. 在循环中，minnum/maxnum记录的最长/最短单词的位置是这个单词的末尾，输出应找到单词开始的位置再输出，这个写反了。
   

2. 循环结束时，可能最后还有一个单词，应该也统计进答案中。

   望采纳！

如何用c语言的数据结构做一个英语词典,要求是:用二叉树,能实现建立词典,查找插入删除单词

#include
《stdio.h》
#include
《malloc.h》
#include
《string.h》
#include
《ctype.h》
#define
MAXWORD
100
typedef
struct
tnode{
char
*word;
int
count;
struct
tnode
*left;
struct
tnode
*right;
//
tnode(char
*s,
int
w,
tnode
*p,
tnode
*q){
//
//
}
}*tnodeptr;
struct
tnode
*addtree(struct
tnode
*,
char
*);
void
deltree(struct
tnode
*,
char
*);
void
treeprint(struct
tnode*,
FILE
*fp,
int
n,
int
&m);
void
showMenu();
void
main()
{
int
N,
k;
FILE
*fp;
struct
tnode
*root;
char
word,
txt;
root=NULL;
while
(1)
{
showMenu();
scanf("%d",
&N);
switch(N)
{
case
1:
printf("连续输入,字符
0
结束:\n");
while
(scanf("%s",
word)!=EOF)
{
if(word==’0’)
break;
if(isalpha(word))
root=addtree(root,
word);
}
printf("单词已插入\n");
break;
case
2:
if(root==NULL)
{printf("NULL字典\n");
break;}
printf("字典:\n");
treeprint(root,
fp,
0,k
=
1);
break;
case
3:
printf("输入删除的单词\n");
scanf("%s",
word);
deltree(root,
word);
break;
case
4:
printf("输入保存文件名:
");
scanf("%s",
txt);
strcat(txt,
".txt");
fp=fopen(txt,
"w");
if(fp==NULL)
{printf("文件写错误!");
break;}
treeprint(root,
fp,
1,
k
=
1);
fclose(fp);
printf("以保存到%s
\n",
txt);
break;
case
0:
return
;
default:
printf("输入错误!");
break;
}
}
return
;
}
struct
tnode*
talloc();
char
*strdup(char*);
struct
tnode
*addtree(struct
tnode
*p,
char
*w)
{
int
cond;
if
(p==NULL)
{
p=talloc();
p-》word=strdup(w);
p-》count=1;
p-》left=p-》right=NULL;
}
else
if((cond=strcmp(w,
p-》word))==0)
p-》count++;
else
if
(cond《0)
p-》left=addtree(p-》left,
w);
else
p-》right=addtree(p-》right,
w);
return
p;
}
/**************************************************************************
*
分4种情况:
*
1.
叶子结点:直接删除;
*
2.
结点只有左孩子:将该左孩子连接到该结点的双亲;
*
3.
结点只有右孩子:将该右孩子连接到该结点的双亲;
*
4.
结点有左右孩子:
*
a.
将该结点左子树的最右结点与该结点互换,然后删除左子树的最右结点;
*
或者
*
b.
将该结点右子树的最左结点与该结点互换,然后删除右子树的最左结点。
***************************************************************************/
void
deltree(struct
tnode
*p,
char
*w)
{
int
co,
t=0;
struct
tnode
*q=NULL,
*r=NULL;
while
(p!=NULL
&&
(co=strcmp(w,
p-》word))!=0)
{
if(co
《
0)
{q
=p;
p=p-》left;
t
=1;}
else
{q
=p;
p=p-》right;
t
=0;}
}
if(p==NULL)
printf("没有此单词!\n");
else
if
(p-》left==NULL
&&
p-》right==NULL)
//《1》
{
if(t==1)q-》left=
NULL;
else
q-》right=NULL;
}
else
if(p-》left
&&
p-》right==NULL)
//《2》
{
if(t==1)
q-》left=p-》left;
else
q-》right
=p-》left;
}
else
if(p-》left==NULL
&&
p-》right)
//《3》
{
if(t==1)q-》left=p-》right;
else
q-》right=p-》right;
}
else
//《4》
{
r=p-》left;
while(r-》right)r
=r-》right;
r-》right
=p-》right;
if(t==1)q-》left
=
r;
else
q-》right
=
r;
}
printf("已删除:%s
\n",
w);
return
;
}
//------------------------
//print
//------------------------
void
treeprint(struct
tnode*
p,FILE
*fp,
int
n,
int
&m)
{
if(p!=NULL)
{
treeprint(p-》left,
fp,
n,m);
if(n)fprintf(fp,
"%-4d%-4d%s\n",m++,p-》count,p-》word);
else
printf("%-4d%-4d%s\n",m++,p-》count,p-》word);
treeprint(p-》right,
fp,
n,m);
}
}
struct
tnode
*talloc()
{
return
(struct
tnode*)malloc(sizeof(struct
tnode));
}
char
*strdup(char*s)
{
char
*p;
p=(char*)malloc(strlen(s)+1);
if(p!=NULL)
strcpy(p,
s);
return
p;
}
void
showMenu()
{
printf("\n
输入选择\t
\
\n
1.
输入单词
\
\n
2.
查看字典
\
\n
3.
删除单词
\
\n
4.
保存字典
\
\n
0.
退出\n");
}

给你一个字典，一段文字， 编个程序，输出文字里面所有的单词个数

//字典的我就不写了，这个是前几天写的，给你参考一下
/* 实现：删除重复单词
从同目录下读入文本 wordin.txt ，进行处理，输出到 wordout.txt
*/
#include《stdio.h》
#include《stdlib.h》
#include《windows.h》
int delCword(char *temp,char *newstr) //temp 为原字符串，newstr 为处理后的字符串
{ //#include《stdlib.h》 #include《windows.h》 //需要头文件 存在隐患：未检测newstr的大小
typedef struct Mystr
{ char *str;
Mystr *next;
}mystr;
char last="",chlast;
int n=0,k=0,flag=1;
Mystr *head=NULL,*st,*delpt,*lastpt;
newstr=’\0’;
do
{ chlast=*temp++;
//从第一个字母开始保存于last中，遇到非字母则得到一个单词
if(isalpha(chlast) || isalnum(chlast) || ’-’==chlast)
{ last=’\0’; }
else { st=head;
while(st)
{ if(!strcmp(st-》str,last)) { flag=0;break; }//与现存单词比较
st=st-》next;
}
if(1==flag && k》0) //没有重复的则存于链表中
{ Mystr *pt=(Mystr *)malloc(sizeof(Mystr));
pt-》str=(char *)malloc(sizeof(char)*(k+1));
pt-》next=NULL;
strcpy(pt-》str,last);
if(0==n) lastpt=head=pt;
else { lastpt-》next=pt; lastpt=pt; }
n++;
}
flag=1; // 重设标志位，默认为与现存字符串不重复
k=0;
}
}while(chlast);
st=head;
while(st) //复制到字符串
{ strncat(newstr,st-》str,strlen(st-》str)); strncat(newstr," ",1);
st=st-》next;
}
st=head;
while(st) //清理垃圾
{ delpt=st-》next; free(st-》str); free(st);
st=delpt;
}
return n;
}
void main()
{ char *s2,*s3,ch;
FILE *fp;
int i=0;
if((fp=fopen("wordin.txt","r"))!=NULL) //从文本输入
{ fseek(fp,0,SEEK_SET);
fseek(fp,0,SEEK_END);
int longBytes=ftell(fp);// 得到文件长度
fseek(fp,0,SEEK_SET);
s3=(char *)malloc(sizeof(char)*(longBytes+1));
s2=(char *)malloc(sizeof(char)*(longBytes+1));

//fread(s3,longBytes,1,fp);
i=0;
while((ch=fgetc(fp))!=EOF)
s3=ch;
s3=’\0’;
}
fclose(fp);
printf("\n元字符串:%s\n",s3);
printf("%d :\n%s",delCword(s3,s2),s2); //调用函数删除重复单词,并输出结果
if((fp=fopen("wordout.txt","w+"))!=NULL) //输出到文本
fwrite(s2,strlen(s2),1,fp);

fclose(fp);
printf("\n");
free(s2);
free(s3);
}

C语言如何将一个字符串中的单词分别存到另一个二维数组

/*通过gcc编译*/
#include 《stdio.h》
#include 《string.h》
int isalpha(char t)
{
return( (t》=’a’&&t《=’z’) || (t》=’A’&&t《=’Z’) );
}
int main()
{
char line;
char word;
char tmp={"\0\0"};
int i,length,totalNumber;
int prvIsAlpha;
while(1)
{
gets(line);
if(line==’\0’) break;
/*如果输入空行的话就退出程序*/
totalNumber=0;
length=strlen(line);
/*如果当前字符是字母那么通过判断前一个字符是不是字母来判断当前单词的输入是否断开*/
prvIsAlpha=0;
for(i=0;i《length;++i)
if(isalpha(line))
{
tmp;
if(prvIsAlpha) strcat(word,tmp);
else word;
prvIsAlpha=1;
}
else prvIsAlpha=0;
/*输出结果*/
if(totalNumber》1)
{
printf("There are %d words.\nThey are %s",totalNumber,word);
for(i=1;i《totalNumber;++i)printf(",%s",word);
printf(".\n");
}
if(totalNumber==1)
printf("There is 1 word.\nIt is %s.\n",word);
if(totalNumber==0)
printf("There is no word.\n");
/*结果输出完毕*/
}
return 0;
}

找出一句话中最长的单词并打印

#include 《stdio.h》
int ischar(char ch)
{
return ((ch 》= ’A’ && ch 《= ’Z’) || (ch 》= ’a’ && ch 《= ’z’)) ? 1 : 0;
}
int main(void)
{
char szsrc;
int maxlen = {0, 0};
int cumax = 0;
char longword;
int i = 0;
gets(szsrc);
while (1)
{
if (ischar(szsrc))
{
longword;
}
else
{
longword = ’\0’;
if (maxlen)
cumax = 1 - cumax;
maxlen = 0;
}
if (szsrc == ’\0’)
break;
i++;
}
printf("the longest word: %s\n", longword);
}