小项目 ： 计算库函数中单词的个数第30天

#ifndef _FILE_H_
#define _FILE_H_

#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <stdbool.h>
#include "file.h"
#include "show.h"

#define MAX 4096
#define MAX_WORD 520

typedef struct word
{
    char *str;
    int counter;
}word_t;

extern void write_queue(queue_t *, char *);
extern void deal_one_file(queue_t *, char *);
extern void deal_one_line(queue_t *, char *);

void process_word(queue_t *, char*);
word_t *mk_word(char *);

int str_compare(const void*, const void *);
#endif//_FILE_H_

#ifndef _SHOW_H_
#define _SHOW_H_

#include "file.h"
#include "queue.h"

void show_result(queue_t *);
void destroy_result(queue_t *);
void *output_queue(queue_t *, int);

void destroy_word(void *);
int word_compare(const void *, const void *);


#endif//_SHOW_H_

//file.c
#include "file.h"
#include "queue.h"

void write_queue(queue_t *s, char *file_list)
{
    char buffer[MAX];
    FILE *fp_read_list;

    if(NULL == (fp_read_list = fopen(file_list, "r"))) {
        printf("Fail fopen%s<file>: %d : %s.
", file_list, __LINE__, strerror(errno));
        return ;
    }

    while(fgets(buffer, MAX, fp_read_list))
    {
        if('
' == buffer[strlen(buffer) - 1]) {
            buffer[strlen(buffer) - 1] = '';
        }
        printf("Parse file: %s 
", buffer);
        deal_one_file(s, buffer);
    }

    fclose(fp_read_list);
}

void deal_one_file(queue_t *s, char *file_one)
{
    char buffer[MAX];
    FILE *fp_file_one;

    if(NULL == (fp_file_one = fopen(file_one, "r"))) {
        printf("Fail fopen%s<file>: %d : %s.
", file_one, __LINE__, strerror(errno));
        return ;
    }

    while(fgets(buffer, MAX, fp_file_one))
    {
        deal_one_line(s, buffer);
    }

    fclose(fp_file_one);
}

void deal_one_line(queue_t *s, char *line_one)
{
    int i = 0;
    //char buffer[MAX_WORD];
    char *buffer;

    buffer = calloc(1, MAX_WORD);
    for(i = 0; *(line_one + i); i ++)
    {
        if(! ((*(line_one + i) >= 'a' && *(line_one + i) <= 'z') || 
                (*(line_one + i) >= 'A' && *(line_one + i) <= 'Z'))) {
            *(line_one + i) = ' ';
        }
    }

    while((buffer = strsep(&line_one, " 
")) != NULL)
    {
        if(strlen(buffer) > 2) {
            process_word(s, buffer);    
        }
    }
    free(buffer);
    buffer = NULL;
}

void process_word(queue_t *s, char *str)
{
    word_t *ret;

    ret = queue_search(s, str, str_compare);

    if(ret) {
        ret->counter ++;
    }
    else {
        queue_enqueue(s, mk_word(str));
    }
}

word_t *mk_word(char *str)
{
    word_t *w;

    w = calloc(1, sizeof(word_t));
    w->str = calloc(100, sizeof(char *));

    strcpy(w->str, str);
    w->counter = 1;

    return w;
}

int str_compare(const void * first, const void *second)
{
    const char *f = first;
    const word_t *s = second;

    return strcasecmp(f, s->str);
}

#ifndef _QUEUE_H_
#define _QUEUE_H_

#include "file.h"
#include "show.h"

typedef struct node 
{
    void *data;
    struct node *next;
}node_t;

typedef struct 
{
    struct node *head;
    struct node *tail;
}queue_t;

extern void queue_init(queue_t *);
extern void queue_destroy(queue_t *, 
        void (*destroy)(void *));
extern void queue_enqueue(queue_t *, void *);
extern void    *queue_dequeue(queue_t *);
extern bool queue_is_full(queue_t *);
extern bool queue_is_empty(queue_t *);
extern void *queue_search(queue_t *,
        const void *key,
        int (*compare)(const void *, const void *));

extern void queue_sort(queue_t *,
        int (*compare)(const void *, const void *));
extern node_t *find_min_queue(queue_t *, 
        int (*compare)(const void *, const void *));
extern void delete_queue(queue_t *, node_t *);
extern void _queue_enqueue(queue_t *, node_t *);

extern void *queue_retriver(queue_t *, int idx);

extern node_t *mk_node(void *);

#endif//_QUEUE_H_

//quue.c
#include "file.h"
#include "queue.h"

void queue_sort(queue_t *queue,
        int (*compare)(const void*, const void *))
{
    node_t *min;
    queue_t s_new;

    queue_init(&s_new);

    while(! queue_is_empty(queue)) 
    {
        min = find_min_queue(queue, compare);
        delete_queue(queue, min);
        min->next = NULL;
        _queue_enqueue(&s_new, min);
    }
    queue->head = s_new.head;
    queue->tail = s_new.tail;
}

//-----------------------------find_min_queue-----------------------------
node_t *find_min_queue(queue_t *queue, 
        int (*compare)(const void *, const void *))
{
    node_t *min, *find;

    find = queue->head;
    min = queue->head;

    while(find && find->next)
    {
        if(compare(find->next->data, min->data) < 0) {
            min = find->next;
        }
        find = find->next;
    }
    return min;
}

void delete_queue(queue_t *queue, node_t *min)
{
    node_t *delete;

    delete = queue->head;

    if(delete == min) {
        queue->head = delete->next;

        return ;
    }

    while(delete && delete->next)
    {
        if(delete->next == min) {
            if(delete->next == queue->tail) {
                queue->tail = delete;
            }
            delete->next = delete->next->next;
        }
        delete = delete->next;
    }
}

void _queue_enqueue(queue_t *queue, node_t *data)
{
    if(! queue->head) {
        queue->head = data;
        queue->tail = data;
    }
    else {
        queue->tail->next = data;
        queue->tail = data;
    }
}
//-----------------------------find_min_queue-----------------------------

void *queue_search(queue_t *queue,
        const void *key,
        int (*compare)(const void*, const void *))
{
    node_t *find;

    find = queue->head;
#if 0
    while(find && find->next) 
    {
        for(; find; find = find->next)
        {
            if(0 == compare(key, find->data)) {
                return find->data;
            }
        }
    }
#endif
    while(find) {
        if(compare(key, find->data) == 0) {
            return find->data;
        }
        find = find->next;
    }

    return NULL;
}

bool queue_is_empty(queue_t *queue)
{
    return queue->head == NULL;
}

bool queue_is_full(queue_t *queue)
{
    return false;
}

void *queue_dequeue(queue_t *queue)
{
    node_t *delete = NULL;
    void *data;

    delete = queue->head;
    queue->head = delete->next;

    data = delete->data;
    free(delete);
    
    return data;
}

void queue_enqueue(queue_t *queue, void *n)
{
    node_t *en;

    en = mk_node(n);
    if(! queue->head) {
        queue->head = en;
        queue->tail = en;
    }
    else {
        queue->tail->next = en;
        queue->tail = en; 
    }
}

node_t *mk_node(void *n)
{
    node_t *mk;
    
    mk = calloc(1, sizeof(node_t));
    mk->data = n;
    mk->next = NULL;

    return mk;
}

void queue_init(queue_t *queue)
{
    queue->head = NULL;
    queue->tail = NULL;
}

void queue_destroy(queue_t *queue,
        void (*destroy)(void *))
{
    if(destroy) {
        destroy(queue_dequeue(queue));
    }
    else {
        queue_dequeue(queue);
    }
}

//main.c
#include "file.h"
#include "show.h"
#include "queue.h"

int main(int argc, char *argv[])
{
    int i = 0;
    queue_t s, *p;
    p = &s;
    p = NULL;

    
    queue_init(&s);
    for(i = 1; i < argc; i ++)
    {
        write_queue(&s, argv[i]);
    }

    show_result(&s);

    destroy_result(&s);

    return 0;
}

void destroy_result(queue_t *queue)
{
    queue_destroy(queue, destroy_word);
}

void destroy_word(void *str)
{
    word_t *w;

    free(w->str);
    free(w);
}

//-----------------------show------------------------

void show_result(queue_t *queue)
{
    word_t *w;
    int i = 0;
    
    printf("Being sort ...
");
    queue_sort(queue, word_compare);

    while((w = output_queue(queue, i)))
    {
        printf("%d : %s
", w->counter, w->str);
        i ++;
    }
}

int word_compare(const void *first, const void *second)
{
    const word_t *f = first;
    const word_t *s = second;

    return f->counter - s->counter;
}

void *output_queue(queue_t *queue, int idex)
{
    node_t *w;
    int i = 0;

    w = queue->head;
#if 1
    for( ; i < idex; i ++)
    {
        w = w->next;
    }
    if(w) {
        return w->data;    
    }
#else
    while(w && i <idex)
    {
        i ++;
        w = w->next;
    }

    if(w) {
        return w->data;
    }
#endif
    return NULL;
}

//-----------------------show------------------------

　　1.功能 ： 计算文件单词出现的次数，并按照从小到大排序， 

　　2. 需求 ： 需要自己提供库文件，以及需要读取的文件列表文件。