链表实例：对英语文本文件单词字符出现频率统计

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


#define WORD_LEN 25


typedef struct word_info{
    char word[WORD_LEN];
    struct word_info *prev;
    struct word_info *next;
    int cnt;
}word_info;
 16
FILE * open_file(const char *filename){　
    FILE *fp = NULL;

    fp = fopen(filename,"r");
    if(!fp){
        fprintf(stderr, "fopen %s error
", filename);
        return NULL;
    }

    return fp;
}

static word_info *Creat_node(void){
    word_info *pnew;
    pnew = (word_info *)malloc(sizeof(word_info));
    if(!pnew){
        fprintf(stderr, "malloc error");
        return NULL;
    }
    pnew->prev = NULL;
    pnew->next = NULL;
    pnew->cnt = 0;

    return pnew;
}

int insert_node(word_info **phead, word_info *pnew){
    word_info * pcur = *phead;
    if(!*phead){
        *phead = pnew;
        return 0;
    }
    do{
        if(strcasecmp(pcur->word, pnew->word) == 0){
            pcur->cnt++;
            free(pnew);
            return 0;
            }    
        if(pcur->next != NULL)
            pcur = pcur->next;
        else
            break;
    }while(1);
    
    pnew->prev = pcur;
    pcur->next = pnew;

    return 0;
}

int read_words(FILE *fp,word_info **phead){
    char word[WORD_LEN];
    word_info *pnew;
    int flag = 1;
    int i = 0;
    int ch;

    pnew = Creat_node();
    if(!pnew)
        return -1;
    
    while ((ch = fgetc(fp)) != EOF){
        if(isalpha(ch)){
            word[i++] = ch;
            flag  = 0;
        }
        else{
            if(ch == '?'){
                strcpy(pnew->word, "?");
                pnew->cnt++;
                insert_node(phead, pnew);
                pnew = Creat_node();    
            }
            if(ch == '.'){
                strcpy(pnew->word, ".");
                pnew->cnt++;
                insert_node(phead, pnew);
                pnew = Creat_node();    
            }
            if(ch == ','){
                strcpy(pnew->word, ",");
                pnew->cnt++;
                insert_node(phead, pnew);
                pnew = Creat_node();    
            }
            if(ch == '"'){
            strcpy(pnew->word, """);
            pnew->cnt++;
            insert_node(phead, pnew);
            pnew = Creat_node();    
            }
            if((isblank(ch) || ch == ',' ||    ch == '!' || ch == '.' || 
                        ch == '"' || ch == '?')    && !flag)
            {
                word[i] = 0;
                strncpy(pnew->word, word, i+1);
                pnew->cnt++;
                insert_node(phead, pnew);
                pnew = Creat_node();
                flag = 1;
                i = 0;    
            }
        }
    }
    if(!i)
        free(pnew);
    
    return 0;
}
　/*
　　　　还有就是双链表的弊端，还要判断下个节点是否为空，设置下个节点的prev。判断上一个节点是否为空
　　　（这是没有无头节点的弊端如果是带头节点，哪怕是第一个带数据节点的prev也不会为空，就不用分别处理）
　　　　设置上一个节点的next。
*/
void swap_node(word_info *w1, word_info *w2){
    if(w1->next == w2){
        if(w2->next != NULL)
            w2->next->prev = w1;
        if(w1->prev != NULL)
            w1->prev->next = w2;
        w1->next = w2->next;
        w2->prev = w1->prev;
        w1->prev = w2;
        w2->next = w1;
    }else{
        if(w1->next != NULL){
            w1->next->prev = w2;
        }
        if(w1->prev != NULL){
            w1->prev->next = w2;
        }
        if(w2->next != NULL){
            w2->next->prev = w1;
        }
        if(w2->prev != NULL){
            w2->prev->next = w1;
        }
        word_info *w1next = w1->next;
        word_info *w1prev = w1->prev;
        w1->next = w2->next;
        w1->prev = w2->prev;
        w2->next = w1next;
        w2->prev = w1prev;
    }
}

int sortByCnt(word_info **phead){
    word_info *head =  *phead;
    int flag = 1;
　　
    if(head->prev != NULL)
        head = head->prev;
    while(head != NULL){
        word_info *headnext = head->next;
        while(headnext != NULL){
            if(head->cnt < headnext->cnt){
                swap_node(head, headnext);
                word_info * tmp = head;
                head = headnext;
                headnext = head;
            }
            headnext = headnext->next;
        }
        if(flag){
            *phead = head;
            flag = 0;
        }
        head = head->next;
    }
    return 0;
}


void print_words(word_info *phead){

    word_info *pcur = phead;
    while(pcur){
        printf("%30s: appears %3d times
", pcur->word
                , pcur->cnt);
        pcur = pcur->next;
    }
}


void destroy_link(word_info *phead){
    word_info *pcur = phead, *ptmp;

    while(pcur){
        ptmp = pcur->next;
        free(pcur);
        pcur = ptmp;
    }
}

int main(int argc, char * argv[])
{
    FILE *fp;
    word_info *head = NULL;
    int ret;

    fp = open_file(argv[1]);
    if(!fp)
        return -1;

    ret = read_words(fp, &head);
    if(ret < 0)
        fprintf(stderr, "read words error");
    sortByCnt(&head);
    print_words(head);
    destroy_link(head);
    fclose(fp);

    return 0;
}

这是用的双向链表，但是没有体现出双向链表的优点。基本都是正序操作。

Running Demo: