原题是这样的
/*从键盘输入一串英文，编程统计字符串中英文单词的个数。并按出现频次升序排序显示每个单词出现的次数*/
可我只会前面的统计总的单词数量，我想到要用结构体，但不会如何将输入的单词放入结构体中，
求论坛内的大神们教教我，谢谢。
#include <stdio.h>
#include <string.h>
//定义total函数计算总的单词个数
total(char str[])
{
    int sum=0,i;
    for(i=0;str[i]!='#';i++)
    {
        if((str[i])==' '||(str[i])==','||(str[i])=='.'||(str[i])=='?'||(str[i])=='!')
            sum++;
    }
    printf("total=%d\n",sum);
    return(sum);
}
/*定义结构体word内存放单词和个数*/
struct wordcount
    {
        char str1[20];
        int strC;
    };
void main()
{
    char str[1000];
    printf("输入一串英文：\n");
    gets(str);
    total(str);

}

假如你要输入10个单词，就声明下wordcount word[10];
然后for(i=0;i<10;i++){gets(word[i].str1)}

#include <stdio.h>
#include <string.h>
struct wordcount
    {
        char str1[20];
        int strC;
    };
void main()
{
    int i;
    printf("输入一串英文：\n");
    wordcount word[2];
    for(i=0;i<2;i++){
        gets(word[i].str1);
        }
   puts(word[0].str1);
}//这个是输入两个单词，先输入一个单词，按回车，再输入一个单词按回车，之后打印第一个单词，你仿照下

单词数量没法固定，可以声明一个较大的结构体数组来存储，或者动态创建一个链表的方式来存储比较好

没做完strcmp部分，晚上做完了再传。

[ 本帖最后由 comewest 于 2014-12-16 14:07 编辑 ]

链表的查询效率那么低，用链表做不是好主意，除非你另外做出高效查询的链表结构。

那请教下T版，除了链表的方式，还有什么方式较适合动态增加的？

单词量少，直接用数组做咯，其实用动态分配内存在堆上开辟一个足够大的数组也可以。真正适应动态增加的模型，在C中比较麻烦，但在C++中可以用标准类库vector，效率非常高，它妙在可以与数组一样的用法而不失链表的方便。总之，如果守着C，真是什么都比较麻烦的，若是非要练手，当然也可以一试，不过在实用中，我是不会再费这劲了。

哦 谢谢！C++目前只是自学了下基础，没应用过还不太清楚

自己补充排序部分吧：

/*
http://bbs.bccn.net/thread-439943-1-1.html

题目：从键盘输入一串英文，编程统计字符串中英文单词的个数。并按出现频次升序排序显示每个单词出现的次数
*/

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

// 数据结构
struct WordItem                         // 字典项目
{
    char word[30];                      // 单词
    size_t frequency;                   // 出现频率
};

// 全局常数
const size_t MaxWordsNumber = 1000;     // 最大单词数目
const char* seps = " .,()*%!'\"\n";

// 函数原型
void Pause(void);
void ReadWords(char* text, const char* seps, WordItem* dictionary);
void ListDictionary(const WordItem* dictionary, size_t count);
size_t FindWord(const char* word, const WordItem* dictionary, size_t count);

// 程序主入口
int main(void)
{
    char text[] = "vb. To translate all the source code of a program from a high-level language into object code prior \
                   to execution of the program. Object code is executable machine code or a variation of machine code. \
                   More generally, compiling is sometimes used to describe translating any high-level symbolic description \
                   into a lower-level symbolic or machine-readable format. A program that performs this task is known as \
                   a compiler. See also compiler (definition 2), compile time, high-level language, machine code, source \
                   code. Compare interpret.";

    WordItem* dictionary = (WordItem*) calloc(MaxWordsNumber, sizeof(WordItem));
    ReadWords(text, seps, dictionary);
    ListDictionary(dictionary, MaxWordsNumber);
    free(dictionary);

    Pause();
    return EXIT_SUCCESS;
}

// 暂停程序等待按键继续
void Pause(void)
{
    printf_s("\nPress any key to continue...");
    _getch();
}

// 输出字典数组明细
void ListDictionary(const WordItem* dictionary, size_t count)
{
    for (size_t index = 0; (index < count) && (strlen(dictionary[index].word) > 0); ++index)
    {
        printf_s("%s, %u\n", dictionary[index].word, dictionary[index].frequency);
    }
}

// 从字符串中提取单词构造字典数组
void ReadWords(char* text, const char* seps, WordItem* dictionary)
{
    char* nextToken;
    char* token = strtok_s(text, seps, &nextToken);
    while (token != NULL)
    {
        size_t index = FindWord(token, dictionary, MaxWordsNumber);
        if (index < MaxWordsNumber)
        {
            strcpy_s(dictionary[index].word, _countof(dictionary[index].word), token);
            ++dictionary[index].frequency;
        }
        token = strtok_s(NULL, seps, &nextToken);
    }
}

// 从字典数组中查找指定的单词，若存在则返回其在字典数组中的下标，否则返回末尾下标
size_t FindWord(const char* word, const WordItem* dictionary, size_t count)
{
    size_t index;

    for (index = 0; (index < count) && (strlen(dictionary[index].word) > 0); ++index)
    {
        if (strcmp(dictionary[index].word, word) == 0)
        {
            break;
        }
    }

    return index;
}