C程序设计（第二版 新版）第六章 习题

最新推荐文章于 2022-11-23 14:51:53 发布
最新推荐文章于 2022-11-23 14:51:53 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： C Programing Language Note
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenyiming_1990/article/details/8495608
版权

1. 统计输入各个c语言关键字出现的次数（6.3）
其中： #define NKEYS （sizeof keytab / sizeof(struct key)）
sizeof 是一个一元运算符   sizeof 对象    或者   sizeof  （类型名字）
sizeof 可以用在#define 中（预处理不计算#define语句中的表达式），但是不能用在#if条件编译中（预处理不对类型名进行分析），
利用结构数组：

#include<stdio.h>
#include<ctype.h>
#include<string.h>

#define MAXWORD 100
#define NKEYS (sizeof keytab / sizeof(struct key))

struct key
{
    char *word;
    int count;
}keytab[]={
    "auto", 0,
    "break",0,
    "case", 0,
    "char", 0,
    "const",0,
    "continue",0,
    "unsigned",0,
    "void", 0,
    "volatile", 0,
    "while",0
};

int getword(char *, int);
int binsearch(char *, struct key *, int);

int main()
{
    int n;
    char word[MAXWORD];
    while(getword(word,MAXWORD) != EOF)
   {
       if(isalpha(word[0]))
          if((n = binsearch(word,keytab,NKEYS)) >= 0)
              keytab[n].count++;
   }
   for(n = 0; n < NKEYS; n++)
     if(keytab[n].count> 0)
   printf("%4d %s\n",keytab[n].count,keytab[n].word);
     return 1;
}

int binsearch(char *word, struct key tab[], int n)
{
    int cond;
    int low, high,mid;
    low = 0;
    high = n -1;
    while(low < high)
    {
       mid = (low + high)/2;
       if((cond = strcmp(word,tab[mid].word)) < 0)
          high = mid -1;
       else if(cond > 0)
          low = mid + 1;
       else
          return mid;
     }
    return -1;
}

int getword(char *word, int lim)
{
    int c, getch();
    void ungetch(int);
    char *w = word;
    while((isspace(c = getch())))
       ;
    if( c != EOF)
       *w++ = c;
    if(!isalpha(c))
    {
       *w = '\0';
       return c;
    }
    for(; --lim > 0; w++)
    if(!isalnum(*w = getch()))
    {
       ungetch(*w);
       break;
    } 
    *w = '\0';
    return word[0];
}

#define BUFSIZE 1000
int buf[BUFSIZE];
int bufp = 0;

int getch()
{
    return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c)
{
     if(bufp >= BUFSIZE)
         printf("the stack of ungetch is full\n");
     else
         buf[bufp++] = c;
}


2. 上题中利用指向结构体的指针
mid = （low + high）/ 2  /* 错误 */  两个指针之间的假发运算是非法的
mid = low + (high - low) / 2
&tab[-1]  和 &tab[n] : 前者是错误的，后者是正确的，后者和 tab + n  是等价的，这个地址是真是存在的，但是对地址指向操作和运算操作都是非法的。 
 
 
 

 

 
 
int main()
{
    struct key *p;
    char word[MAXWORD];
    while(getword(word,MAXWORD) != EOF)
    {
      if(isalpha(word[0]))
         if((p = binsearch(word,keytab,NKEYS)) != NULL)
		p->count++;
     }
     for(p = keytab; p < keytab + NKEYS; p++)
        if(p->count> 0)
	   printf("%4d %s\n",p->count,p->word);
     return 1;
}

struct key * binsearch(char *word, struct key tab[], int n)
{
     int cond;
     struct key *low, *high, *mid;
     low = &tab[0];
     high = &tab[n] -1;
     while(low < high)
     {
        mid = low + (high - low)/2;
        if((cond = strcmp(word,mid->word)) < 0)
	  high = mid -1;
        else if(cond > 0)
	  low = mid + 1;
        else
	  return mid;
     }
     return NULL;
}
 
 
 

 

 
 3.统计单词出现的频率并俺字符顺序排序（6.5）
 以下几个文件夹为常用函数文件夹： 
 
 

 

 
  
 
GetchAndUngetch.c

#define BUFSIZE 1000
int buf[BUFSIZE];
int bufp = 0;

int getch()
{
    return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c)
{
    if(bufp >= BUFSIZE)
        printf("the stack of ungetch is full\n");
    else
        buf[bufp++] = c;
}

TallocAndStrdup.c
#include<malloc.h>

struct tnode *talloc()
{
    return (struct tnode *)malloc(sizeof(struct tnode));
}

char *strdp(char *s)
{
    char *p;
    p = (char *)malloc(strlen(s)+1);
    if(p != NULL)
        strcpy(p,s);
    return p;
}

getword.c
 int getword(char *word, int lim)
{
    int c, getch();
    void ungetch(int);
    char *w = word;
    //while((isspace(c = getch())) && c != '\n') //for 6-3.c
    while(isspace(c = getch()))
        ;
    if( c != EOF)
        *w++ = c;
    if(!isalpha(c))
    {
        *w = '\0';
        return c;
    }
    for(; --lim > 0; w++)
    if(!isalnum(*w = getch()))
    {
        ungetch(*w);
        break;
    }
    *w = '\0';
    return word[0];
}

主函数
#include<stdio.h>
#include<ctype.h>

#define MAXWORD 100
#define NDISTINCT 1000

struct tnode
{
    char *word;
    int count;
    struct tnode *left;
    struct tnode *right;
};

#include"GetchAndUngetch.c"
#include"TallocAndStrdup.c"
#include"getword.c"

struct tnode *addtree(struct tnode *p,char *p);
void treeprint(struct tnode *root);

int main()
{
    struct tnode *root;
    char word[MAXWORD];
    int i;
    root = NULL;
    while(getword(word,MAXWORD) != EOF)
        if(isalpha(word[0]))
            root = addtree(root,word);
   treeprint(root);
   return 0;
}

struct tnode *addtree(struct tnode *p, char *w)
{
    int cond;
    if(p == NULL)
    {
        p = talloc();
        p ->word = strdp(w);
        p ->count = 1;
        p ->left = p ->right = NULL;
    }
    else if((cond = strcmp(w,p->word)) < 0)
        p ->left = addtree(p->left,w);
    else if(cond > 0)
        p ->right = addtree(p->right,w);
    else 
        p->count++;
    return p;
}

void treeprint(struct tnode *p)
{
    if(p != NULL)
    {
        treeprint(p->left);
                printf("%4d %s\n",p->count, p->word);
        treeprint(p->right);
    }
}
 
 
 4. 读取变量，并按字母是顺序打印变量名字，要求每一组内各变量名前6个字符相同，其余字符不同，6作为一个可以在命令行设定的参数。（6-2） 

 

 
 
#include<stdio.h>
#include<ctype.h>
#include<string.h>
#include<stdlib.h>

struct tnode
{
    char *word;
    int match;
    struct tnode *left;
    struct tnode *right;
};

#define MAXWORD 100
#define YES 1
#define NO 0

#include"GetchAndUngetch.c"
#include"TallocAndStrdup.c"
#include"getword.c"

struct tnode *addtreex(struct tnode *, char *, int ,int *);
void treexprint(struct tnode*);

int main(int argc, char *argv[])
{
    struct tnode *root;
    char word[MAXWORD];
    int found = NO;
    int num;
    num = (--argv && (*++argv)[0] == '-') ? atoi(argv[0]+1) :6;
    root = NULL;
    while(getword(word,MAXWORD) != EOF)
    {
        if(isalpha(word[0]) && strlen(word) >= num)
        root = addtreex(root,word,num,&found);
        found = NO;
    }
    treexprint(root);
    return 1;
}

struct tnode *addtreex(struct tnode *p, char *w, int num, int *found)
{
    int cond;
    int compare(char* s, struct tnode *p,  int num, int *found);
    if(p == NULL)
    {
        p = talloc();
        p ->word = strdp(w);
        p ->match = *found;
        p -> left = p -> right = NULL;
    }
    else if((cond = compare(w,p,num,found)) < 0)
        p -> left = addtreex(p->left,w,num,found);
    else if(cond > 0)
        p -> right = addtreex(p->right,w,num,found);
    return p;
}

int compare(char *s, struct tnode *p, int num, int *found)
{
    int i;
    char *t = p->word;
    for(i = 0; *s == *t; i++,s++,t++)
        if(*s == '\0')
            return 0;
    if(i >= num )
    {
        *found = YES;
        p->match = YES;
    }
    return *s - *t;
}

void treexprint(struct tnode *p)
{
    if(p != NULL)
    {
        treexprint(p->left);
        if(p->match == YES)
        printf("%s\n",p->word);
        treexprint(p->right);
    }
}
 
 
 5.编写一个程序，根据单词出现的频率俺降序打印输入的各个不同单词，并在每个单词的前面标上它的出现次数。 

 

 
 
#include<stdio.h>
#include<ctype.h>

#define MAXWORD 100
#define NDISTINCT 1000

struct tnode
{
    char *word;
    int count;
    struct tnode *left;
    struct tnode *right;
};

#include"GetchAndUngetch.c"
#include"TallocAndStrdup.c"
#include"getword.c"

struct tnode *addtree(struct tnode *, char *);
void sortlist();
void treestore(struct tnode *);

struct tnode *list[NDISTINCT];
int ntn = 0;

int main()
{
    struct tnode *root;
    char word[MAXWORD];
    int i;
    root = NULL;
    while(getword(word,MAXWORD) != EOF)
        if(isalpha(word[0]))
            root = addtree(root,word);
    treestore(root);
    sortlist();
    for(i = 0; i < ntn; i++)
        printf("%2d:%20s\n", list[i]->count, list[i]->word);
    return 0;
}

struct tnode *addtree(struct tnode *p, char *w)
{
    int cond;
    if(p == NULL)
    {
        p = talloc();
        p ->word = strdp(w);
        p ->count = 1;
        p ->left = p ->right = NULL;
    }
    else if((cond = strcmp(w,p->word)) < 0)
        p ->left = addtree(p->left,w);
    else if(cond > 0)
        p ->right = addtree(p->right,w);
    else 
        p->count++;
    return p;
}

void treestore(struct tnode *p)
{
    if(p != NULL)
    {
        treestore(p->left);
        if(ntn < NDISTINCT)
           list[ntn++] = p;
        treestore(p->right);
    }
}

void sortlist()
{
    int gap, i, j;
    struct tnode *temp;
    for(gap = ntn/2; gap > 0; gap /=2)
        for(i = gap; i < ntn; i++)
            for(j = i-gap; j >= 0; j-=gap)
            {
                if((list[j]->count) >= (list[j+gap]->count))
                    break;
                temp = list[j];
                list[j] = list[j+gap];
                list[j+gap] = temp;
            }
}
 
 
 
  
 
 
 6.表查找程序。比如：#define IN 1 就把文本IN 和 文本1都存起来，我采用散列表查找方法。 

 

 
 
#include<stdio.h>
#include<string.h>
#include<malloc.h>

struct nlist
{
   struct nlist *next;
   char *name;
   char *defn;
};

#define HASHSIZE 101
struct nlist *hashtab[HASHSIZE];

//hash函数：为字符串s生成散列值
unsigned hash(char *s)
{
   unsigned  hashval;
   for(hashval = 0; *s != '\0'; s++)
      hashval = *s + 31 * hashval;
   return hashval % HASHSIZE;
}

// lookup函数：在hashtab中查找s
struct nlist *lookup(char *s)
{
    struct nlist *np;
    for(np = hashtab[hash(s)]; np != NULL; np = np ->next)
    if(strcmp(s, np->name) == 0)
       return np;
    return NULL;
}

// 将（name，defn）加入到hashtab中
struct nlist *install(char *name, char *defn)
{
   struct nlist *np;
   unsigned hashval;
   if((np = lookup(name)) == NULL)
   {
      np = (struct nlist *)malloc(sizeof(*np));
      if(np == NULL || (np ->name = strdup(name))== NULL)
         return NULL;
      hashval = hash(name);
      np ->next = hashtab[hashval];
      hashtab[hashval] = np;
   }
   else
      free((void *)np->defn);
   if((np->defn = strdup(defn)) == NULL)
      return NULL;
   return np;
}

// 将删除字符串s以及其定义
void undef(char *s)
{
    int h;
    struct nlist *prev, *np;
    prev = NULL;
    h = hash(s);
    for(np = hashtab[h]; np != NULL; np = np ->next)
    {
       if(strcmp(s,np->name) == 0)
          break;
       prev = np;
    }
    if(np != NULL)
    {
       if(prev == NULL)
          hashtab[h]= np->next;
       else
       {
          prev->next = np->next;
          free((void *)np->name);
          free((void *)np->defn);
          free((void *)np);
       }
    }
}

void print()
{
    int i;
    for(i = 0; i < HASHSIZE; i++)
      if(hashtab[i] != NULL)
      {
         struct nlist *temp = hashtab[i];
         while(temp)
         {
            printf("%15s %5s\n",temp->name, temp->defn);
            temp = temp ->next;
         }
       }
}

int main()
{
    install("chenyiming","1");
    install("huangyazhen","2");
    install("xuyang","3");
    install("wangchao","4");
    install("zhengnan","5");
    print();
    return 1;
}
 
 
 

 


  7.编写一个适合c语言程序使用的#define处理的简单版本（即无参数的情况）。（练习6-6）你会发现getch和ungetch函数非常有用。 

 

 
 
#include<stdio.h>
#include<ctype.h>
#include<string.h>

#define MAXWORD 100

struct nlist
{
	struct nlist *next;
	char *name;
	char *defn;
};

#include"getword.c"
#include"TallocAndStrdup.c"
#include"GetchAndUngetch.c"

void error(int, char *);
struct nlist *install(char *,char *);
struct nlist *lookup(char *);
void skipblanks();
void getdef();
void undef(char *);

int main()
{
	char w[MAXWORD];
	struct nlist *p;
	
	while(getword(w,MAXWORD) != EOF)
	{
		if(strcmp(w,"#")== 0)
			getdef();
		else if(!isalpha(w[0]))
			printf("%s",w);
		else if((p = lookup(w)) == NULL)
			printf("%s",w);
		else
			ungets(p->defn);
	}
	return 0;
}

void getdef()
{
	void undef(char *);
	int c, i;
	char def[MAXWORD], dir[MAXWORD], name[MAXWORD];
	
	skipblanks();
	if(!isalpha(getword(dir,MAXWORD)))
		error(dir[0],"getdef:expecting a directive after #");
	else if(strcmp(dir,"define") == 0)
	{
		skipblanks();
		if(!isalpha(getword(name,MAXWORD)))
			error(name[0],"getdef: non-alpha - name expected");
		else
		{
			skipblanks();
			for(i = 0; i < MAXWORD - 1; i++)
				if((def[i] = getch()) == EOF || def[i] =='\n')
					break;
			def[i] = '\0';
			if(i <= 0)
				error('\n',"getdef: incomplete define");
			else
				install(name,def);
		}
	}
	else if( strcmp(dir, "undef") == 0)
	{
		skipblanks();
		if(!isalpha(getword(name,MAXWORD)))
			error(name[0],"getdef:non-alpha in undef");
		else	
			undef(name);
	}
	else
		error(dir[0],"getdef: expecting a directive after #");
}

void error(int c, char *s)
{
	printf("error: %s\n",s);
	while(c != EOF && c != '\n')
		c = getch();
}

void skipblanks()
{
	int c;
	while((c = getch())== ' ' || c == '\t')
		;
	ungetch(c);
}


#define HASHSIZE 101
struct nlist *hashtab[HASHSIZE];

//hash函数：为字符串s生成散列值
unsigned hash(char *s)
{
   unsigned  hashval;
   for(hashval = 0; *s != '\0'; s++)
      hashval = *s + 31 * hashval;
   return hashval % HASHSIZE;
}

// lookup函数：在hashtab中查找s
struct nlist *lookup(char *s)
{
    struct nlist *np;
    for(np = hashtab[hash(s)]; np != NULL; np = np ->next)
    if(strcmp(s, np->name) == 0)
       return np;
    return NULL;
}

// 将（name，defn）加入到hashtab中
struct nlist *install(char *name, char *defn)
{
   struct nlist *np;
   unsigned hashval;
   if((np = lookup(name)) == NULL)
   {
      np = (struct nlist *)malloc(sizeof(*np));
      if(np == NULL || (np ->name = strdup(name))== NULL)
         return NULL;
      hashval = hash(name);
      np ->next = hashtab[hashval];
      hashtab[hashval] = np;
   }
   else
      free((void *)np->defn);
   if((np->defn = strdup(defn)) == NULL)
      return NULL;
   return np;
}

// 将删除字符串s以及其定义
void undef(char *s)
{
    int h;
    struct nlist *prev, *np;
    prev = NULL;
    h = hash(s);
    for(np = hashtab[h]; np != NULL; np = np ->next)
    {
       if(strcmp(s,np->name) == 0)
          break;
       prev = np;
    }
    if(np != NULL)
    {
       if(prev == NULL)
          hashtab[h]= np->next;
       else
       {
          prev->next = np->next;
          free((void *)np->name);
          free((void *)np->defn);
          free((void *)np);
       }
    }
}
 
 
 


                

        

        

    

  


    

      

        

            

              
                
                  大米粒ing
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
C语言程序设计现代方法第二版 第六章答案

				
			

			

				

					qq_29445129的博客
				

				

					04-01
					
					1618
					
				

			

		

		

			
				
1：
#include<stdio.h>
int main(void)
{
	float x,max=0.0;
	do{
		printf("Enter a number:");
		scanf("%f",&x);
		if(x>max)
			max=x;
	}while(x>0);
	printf("\nThe largest numnber entered w...

			
		

	



                

              
                



	

		

			

				
					
《C语言程序设计_现代方法 第2版》课后编程部分习题 第六章

				
			

			

				

					welcome
				

				

					12-25
					
					1539
					
				

			

		

		

			
				
《C语言程序设计_现代方法 第2版》课后编程部分习题 第六章

挑选几个喜欢的程序以备日后回顾


编写程序，找出用户输入的一串数中的最大数。程序需要提示用户一个一个地输入数

#include <stdio.h>
int main(void){
	int i=0;
	float max=0,number=0;
	for(;i<6;i++){
		printf("enter a ...

			
		

	



                


  
              

                


	

		

			

				
					
c语言程序设计第二版第六章课后答案,《C语言程序设计教学资料》课后习题参考答案第六章.doc...

				
			

			

				

					weixin_39902598的博客
				

				

					05-17
					
					393
					
				

			

		

		

			
				
第一题#includevoid main(){int i,j,a[3][3],m=0,n=0;srand(time(NULL));for(i=0;i<3;i++){for(j=0;j<3;j++){a[i][j]=rand()%100;printf("%4d",a[i][j]);if (j==i)m+=a[i][j];if (j+i==2)n+=a[i][j];}printf("\n"...

			
		

	





	

		

			

				
					
C语言程序设计现代方法（第2版）第6章编程题8

				
			

			

				

					rsice的专栏
				

				

					03-31
					
					231
					
				

			

		

		

			
				
#include <stdio.h>

int main() {
	int i,m,n,j;
	printf("Enter number of days in month:");
	scanf("%d",&m);
	printf("Enter starting day of the week (1=sun, 7=sat):");
	scanf("%d",&n);

	...

			
		

	



		

			
		



	

		

			

				
					
C语言程序设计现代方法（第2版）第六章编程题11

				
			

			

				

					rsice的专栏
				

				

					03-31
					
					351
					
				

			

		

		

			
				
#include <stdio.h>

int main() {
	int i,n;
	double e=1.0,temp=1.0;
	printf("Enter a integer:");
	scanf("%d",&n);
	
	for(i=1;i<=n;i++){
		temp*=i;
		e+=1/temp;
	}
	printf("e is:%.20f",e);...

			
		

	





	

		

			

				
					
C语言程序设计教程第四章练习题解析最新版.doc

				
			

			

				

					11-17
				

			

		

		

			
				
"C语言程序设计教程第四章练习题解析最新版.doc"  本资源摘要信息提供了 C 语言程序设计教程第四章的练习题解析，涵盖了函数、变量、作用域、输入输出等多方面的知识点。  一、函数  1.C 语言中的函数可以嵌套调用，...

			
		

	





	

		

			

				
					
C语言程序设计现代方法第2版全部课后习题参考答案.pdf

				
			

			

				

					02-19
				

			

		

		

			
				
《C语言程序设计现代方法第2版》是一本深入学习C语言的经典教材，其全面覆盖了C语言的基础概念、语法和高级特性。书中的499道课后习题是检验学习成果和提升编程能力的重要途径。这些习题涵盖了从基本的数据类型、...

			
		

	





	

		

			

				
					
C语言程序设计第二版习题参考答案解析.doc

				
			

			

				

					11-13
				

			

		

		

			
				
C 语言程序设计第二版习题参考答案解析  本资源为 C 语言程序设计第二版习题参考答案解析，涵盖了 C 语言程序设计的基础知识点，包括数值表示、ASCII 码、逻辑运算、C 语言程序设计基础知识等。  一、判断题  1. 在...

			
		

	





	

		

			

				
					
免费谭浩强C语言程序设计（第五版）习题答案.zip

					
最新发布

				
			

			

				

					12-22
				

			

		

		

			
				
《谭浩强C语言程序设计（第五版）》是一本深受初学者喜爱的C语言教材，它以其浅显易懂的语言和丰富的实例，为初学者提供了全面的C语言学习资源。习题答案作为教材的重要组成部分，是检验学习效果、巩固知识的关键。...

			
		

	





	

		

			

				
					
李峰《C语言程序设计》第2版 教材答案+上机指导

				
			

			

				

					04-10
				

			

		

		

			
				
《C语言程序设计》是李峰教授编著的一本经典的C语言教材，其第二版针对初学者和进阶者提供了全面且深入的C语言学习资源。该教材深受广大编程爱好者和计算机专业学生的喜爱，因其清晰的讲解和丰富的实例而广受好评。...

			
		

	





	

		

			

				
					
C语言程序设计:现代方法第二版习题答案

				
			

			

				

					03-08
				

			

		

		

			
				
<<C语言程序设计:现代方法>>第二版习题答案

			
		

	





	

		

			

				
					
C程序设计（第二版）第六章习题

				
			

			

				

					门外汉的专栏
				

				

					10-15
					
					2293
					
				

			

		

		

			
				
程序来自配套的课后习题一书！ 6.1  输入2个正整数m和n，求其最大公约数和最小公倍数#include void main(){ int p,r,n,m,temp; printf("输入2个正整数n，m："); scanf("%d,%d",&n,&m); if(n {  temp=n;  n=m;  m=temp;//大数放在n中，小数放在m中 } p=n*m;//先将n和m的乘积保存在

			
		

	





	

		

			

				
					
C语言程序设计第六章练习题

				
			

			

				

					weixin_44576241的博客
				

				

					02-16
					
					2013
					
				

			

		

		

			
				
例6.1 对于10个数组元素依次赋值为 0，1，2，3，4，5，6，7，8，9，要求按逆序输出。
# include&lt;stdio.h&gt;
int main()
{
int i,a[10];
for(i=0;i&lt;=9;i++)
a[i]=i;
for(i=9;i&gt;=0;i--)
printf("%d",a[i]);
printf("\n");
return 0;
}


例6....

			
		

	





	

		

			

				
					
C语言程序设计现代方法---第六章：循环

				
			

			

				

					码界吴彦祖
				

				

					02-26
					
					937
					
				

			

		

		

			
				
6.1：while语句  
①：无限循环 
②：程序：显示平方值的表格  
③：程序：数列求和  
6.2：do语句  
程序：计算整数中数字的位数  
6.3：for语句  
①：for语句的惯用法  
②：在for语句中省略表达式  
③：逗号运算符 
④：程序：显示平方值的表格  
6.4：退出循环  
①：break语句 
②：continue语句  
③：go

			
		

	





	

		

			

				
					
请编写一个程序,一本书中需要打印哪些单词出现频率在前20

				
			

			

				

					xiangmes的博客
				

				

					09-19
					
					791
					
				

			

		

		

			
				
/**     
     * @Discription 在此输入一句话描述此文件的作用
     * @author 
     * @created 2016-9-19 下午4:01:54    
     * tags     
     * see_to_target     
     */
    
package com.kiso.base.core.test;

			
		

	





	

		

			

				
					
1233: 华科版C语言程序设计教程（第二版）习题6.7

				
			

			

				

					最有趣的编程
				

				

					01-10
					
					2205
					
				

			

		

		

			
				

			
		

	





	

		

			

				
					
练习 6-4 编写一个程序，根据单词的出现频率按降序打印输入的各个不同单词，并在 每个单词的前面标上它的出现次数

				
			

			

				

					c_cql的博客
				

				

					11-26
					
					4743
					
				

			

		

		

			
				
练习 6-4 编写一个程序，根据单词的出现频率按降序打印输入的各个不同单词，并在
每个单词的前面标上它的出现次数。

			
		

	





	

		

			

				
					
【C语言】词频统计+按频率降序输出

				
			

			

				

					qq_46595470的博客
				

				

					11-23
					
					1345
					
				

			

		

		

			
				
【代码】【C语言】词频统计+按频率降序输出。

			
		

	





	

		

			

				
					
[串] 统计每个单词出现的次数，降序输出（快排）

				
			

			

				

					geodoer
				

				

					12-11
					
					3748
					
				

			

		

		

			
				
/*
【问题】从键盘输入一系列英文单词，单词用空格分割，结束输入后统计每个单词出现的次数，并按照出现次数降序输出每个单词及其出现的次数
【说明】可用strcmp()、qsort()库函数
【方法一】使用结构体数组来对单词进行统计，然后使用qsort对次数进行排序 - 不建议
【方法二】事先不清楚单词的个数，使用链表来组织每个单词，再进行排序 - 普通
【拓展】面对海量数据的读取，应该使用键树（Tr...

			
		

	





	

		

			

				
					
C语言入门经典：C程序设计语言第二版解析

				
			

			

				

					
				

			

		

		

			
				
"C程序设计语言（第2版·新版）非扫描版，是C语言的经典教材，适合初学者。"  《C程序设计语言（第2版·新版）》是由Brian W. Kernighan和Dennis M. Ritchie共同编写的经典C语言教程，通常被称为K&R（Kernighan & ...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值