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

#define TABLE_SIZE   3000
#define FNAME        "file2.txt"

typedef struct {
    char *word;
    int count;
} Word;

int get_word(FILE *fp, char *word, int size)
{
    int c, i = 0;

    do {
        if ((c = getc(fp)) == EOF) return EOF;
    } while (! isalpha(c));
    size--;
    do {
        if (i < size) word[i++] = tolower(c);
        c = getc(fp);
    } while (isalpha(c));
    word[i] = '\0';
    return i;
}

int compare(const void *a, const void *b)
{
    const Word *p1 = a, *p2 = b;
    return p2->count - p1->count;
}

int main()
{
    Word table[TABLE_SIZE];
    char word[128];
    int  n = 0, i;
    FILE *fp = fopen(FNAME, "r");

    if (fp == NULL) return printf("can't open %s\n", FNAME), 1;

    while (get_word(fp, word, sizeof(Word)) != EOF) {
        for (i = 0; i < n; i++)
            if (strcmp(word, table[i].word) == 0) break;
        if (i == n) {
            if (++n == TABLE_SIZE) return printf("too many words\n"), 1;
            table[i].word = strdup(word);
            if (table[i].word == NULL) return printf("out of memory\n"), 1;
            table[i].count = 1;
        } else
            table[i].count++;
    }

    qsort(table, n, sizeof *table, compare);

    for (i = 0; i < n; i++)
        printf("%4d %s\n", table[i].count, table[i].word);
    return 0;
}

>    while (get_word(fp, word, sizeof(Word)) != EOF) {

訂正です。

    while (get_word(fp, word, sizeof word) != EOF) {

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

#define FNAME   "file2.txt"

typedef struct Node Node;
struct Node {
    char *word; int count;
    Node *left, *right;
};

typedef struct {
    Node *np;  int count;
    Node **sp; int index;
} Tree;

void *Malloc(size_t size)
{
    void *p = malloc(size);
    if (p == NULL) fprintf(stderr, "out of memory\n"), exit(1);
    return p;
}

Tree *create_tree(void)
{
    Tree *tp = Malloc(sizeof(Tree));
    tp->np = NULL;  tp->count = 0;
    tp->sp = NULL;  tp->index = 0;
    return tp;
}

char *Strdup(const char *s)
{
    return strcpy(Malloc(strlen(s) + 1), s);
}

void add_tree(Tree *tp, const char *word)
{
    Node *np, **npp = &tp->np;  int diff;

    while (*npp) {
        np = *npp;
        diff = strcmp(word, np->word);
        if (diff == 0) { np->count++; return; }
        npp = (diff < 0) ? &np->left : &np->right;
    }
    np = Malloc(sizeof(Node));
    np->word = Strdup(word);
    np->count = 1;
    np->left = np->right = NULL;
    *npp = np;
    tp->count++;
}

void add_node(Tree *tp, Node *np)
{
    if (np == NULL) return;
    add_node(tp, np->left);
    tp->sp[tp->index++] = np;
    add_node(tp, np->right);
}

int compare_tree(const void *a, const void *b)
{
    Node **p1 = (Node **)a, **p2 = (Node **)b;
    return (*p2)->count - (*p1)->count;
}

void sort_tree(Tree *tp)
{
    tp->sp = Malloc(sizeof(Tree *) * tp->count);
    add_node(tp, tp->np);
    qsort(tp->sp, tp->count, sizeof(Tree *), compare_tree);
}

void print_tree(Tree *tp)
{
    int i;
    for (i = 0; i < tp->count; i++)
        printf("%5d %s\n", tp->sp[i]->count, tp->sp[i]->word);
}

void free_node(Node *np)
{
    if (np == NULL) return;
    free_node(np->left);
    free_node(np->right);
    free(np);
}

void release_tree(Tree *tp)
{
    free_node(tp->np);
    free(tp);
}

int get_word(FILE *fp, char *word, int size)
{
    int c, i = 0;

    do {
        if ((c = getc(fp)) == EOF) return EOF;
    } while (! isalpha(c));
    size--;
    do {
        if (i < size) word[i++] = tolower(c);
        c = getc(fp);
    } while (isalpha(c));
    word[i] = '\0';
    return i;
}

int main()
{
    char word[128];
    Tree *tp;
    FILE *fp = fopen(FNAME, "r");

    if (fp == NULL) return printf("can't open %s\n", FNAME), 1;
    tp = create_tree();
    while (get_word(fp, word, sizeof word) != EOF)
        add_tree(tp, word);
    sort_tree(tp);
    print_tree(tp);
    release_tree(tp);
    return 0;
}

void free_node(Node *np)
{
    if (np == NULL) return;
    free_node(np->left);
    free_node(np->right);
    free(np->word);     /* <-- */
    free(np);
}

void release_tree(Tree *tp)
{
    free_node(tp->np);
    free(tp->sp);       /* <-- */
    free(tp);
}

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <cctype>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;

const char fname[] = "file2.txt";

string get_word(istream& is)
{
    string word;
    int c;
    do {
        c = is.get();
        if (c == EOF) return word;
    } while (! isalpha(c));
    do {
        word += tolower(c);
        c = is.get();
    } while (isalpha(c));
    return word;
}

typedef pair<string, int> SI;

bool compare(const SI& a, const SI& b) { return a.second > b.second; }

int main()
{
    ifstream ifs(fname);
    if (! ifs) return cerr << "can't open " << fname << endl, 1;

    map<string, int> data;
    string word;
    while (word = get_word(ifs), !word.empty())
        data[word]++;

    vector<SI> v(data.begin(), data.end());
    sort(v.begin(), v.end(), compare);
    for (vector<SI>::const_iterator it = v.begin(); it != v.end(); ++it)
        cout << setw(5) << it->second << ' ' << it->first << endl;
}

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

#define HASHSIZE 101 /* ハッシュ表の大きさ (素数) */
#define MAXWORDLEN 128 /* 最大単語長 */
#define FNAME "file2.txt"

int wordlen; /* 単語長 */
unsigned long words, newwords; /* 単語, 新単語カウンタ */
char word[MAXWORDLEN + 1]; /* 現在の単語 */

typedef struct node { /* 2分木のノード */
    struct node *left, *right; /* 左右の子 */
    char *key; /* キー (文字列) */
    int count;                                        /* KAZUMA */
} *nodeptr;

struct node nil = {NULL, NULL, word}; /* 番人 */
nodeptr hashtable[HASHSIZE]; /* ハッシュ表 */
nodeptr *nodearray;                                   /* KAZUMA */
int index;                                            /* KAZUMA */

int hash(char *s) /* 簡単なハッシュ関数 */
{
    unsigned v;

    for (v = 0; *s != '\0'; s++)
        v = ((v << CHAR_BIT) + *s) % HASHSIZE;
    return (int)v;
}

void insert(void) /* 挿入 (登録) */
{
    int cmp;
    nodeptr *p, q;

    words++;
    p = &hashtable[hash(word)];
    while ((cmp = strcmp(word, (*p)->key)) != 0)
        if (cmp < 0) p = &((*p)->left );
        else p = &((*p)->right);
    if (*p != &nil) { (*p)->count++; return; }     /* KAZUMA */
    newwords++;
    if ((q = malloc(sizeof *q)) == NULL
        || (q->key = malloc(wordlen + 1)) == NULL) {
        printf("メモリ不足.\n"); exit(EXIT_FAILURE);
    }
    strcpy(q->key, word);
    q->count = 1;                                  /* KAZUMA */
    q->left = &nil; q->right = *p; *p = q;
}

void traverse(nodeptr p)                              /* KAZUMA */
{
    if (p == &nil) return;
    traverse(p->left);
    nodearray[index++] = p;
    traverse(p->right);
}

int compare(const void *a, const void *b)             /* KAZUMA */
{
    nodeptr x = *(nodeptr *)a, y = *(nodeptr *)b;
    return y->count - x->count;
}

void sort_print(void)                                 /* KAZUMA */
{
    unsigned long i;

    nodearray = malloc(newwords * sizeof nodearray);
    if (nodearray == NULL) printf("メモリ不足.\n"), exit(EXIT_FAILURE);
    index = 0;
    for (i = 0; i < HASHSIZE; i++)
        traverse(hashtable[i]);
    qsort(nodearray, newwords, sizeof nodearray, compare);
    for (i = 0; i < newwords; i++)
        printf("%5d %s\n", nodearray[i]->count, nodearray[i]->key);
}

void getword(void)
{
    int c;

    wordlen = 0;
    do {
        if ((c = getchar()) == EOF) return;
    } while (! isalpha(c));
    do {
        if (wordlen < MAXWORDLEN) word[wordlen++] = tolower(c);
        c = getchar();
    } while (isalpha(c));
    word[wordlen] = '\0';
}

int main()
{
    int i;

    words = newwords = 0;
    for (i = 0; i < HASHSIZE; i++) hashtable[i] = &nil;
    if (freopen(FNAME, "r", stdin) == NULL)
    return fprintf(stderr, "can't open %s\n", FNAME), 1;
    while (getword(), wordlen != 0) insert();
    sort_print();                                     /* KAZUMA */
    return EXIT_SUCCESS;
}