[算法 笔记] 统计给定文章的单词个数

　　问题出自blog：http://blog.csdn.net/v_july_v/article/details/6803368

　　问题：高效统计一篇英文文章里出现的所有单词，按照在文章中首次出现的顺序打印出该单词和它出现的次数。

　　解决方式：利用Trie完成单词匹配，然后利用链表来统计单词出现的个数。

　　源代码：

　　

#include <stdio.h>
#include <stdlib.h>     // for calloc(), free()
#include <string.h>     // for strlen(), memset()

enum { BranchSize = 26, StringSize = 40, NodeMax = 200 }; // 声明常量

/* 链表信息以及相关操作函数 */
struct ListNode
{
    int     m_iCnt;             // 统计单词出现的次数
    char    m_szStr[StringSize];// 当前链表项中单词
    struct ListNode *m_pNxt;    // 指向下一个链表结点
};

struct ListHead
{
    struct ListNode *m_pStart;  // 指向链表开始结点
    struct ListNode *m_pEnd;    // 指向链表末尾结点
};

typedef struct ListNode ListNode;
typedef struct ListHead ListHead;

// 分配头结点
ListHead* AllocListHead()
{
    ListHead *pNew = NULL;

    pNew = (ListHead *) calloc( 1, sizeof( ListHead ) );
    if ( NULL == pNew )
    {
        printf( "Out of Memory.
" );
        return NULL;
    }

    pNew->m_pEnd        = NULL;
    pNew->m_pStart      = NULL;

    return pNew;
}

// 分配链表结点
ListNode* AllocListNode( const char *szStr )
{
    ListNode *pNew = NULL;

    pNew = (ListNode *)calloc( 1, sizeof(ListNode) );
    if ( NULL == pNew )
    {
        printf( "Out of Memory.
" );
        return NULL;
    }

    // 初始化信息
    pNew->m_iCnt = 1;
    pNew->m_pNxt = NULL;
    strncpy( pNew->m_szStr, szStr, strlen( szStr ) );
    pNew->m_szStr[strlen(szStr)] = '';

    return pNew;
}

// 插入链表
int InsertNodeIntoList( ListHead *pHead, const char *szStr )
{
    ListNode *pStart = pHead->m_pStart,
              *pNew   = NULL;

    // 检查参数
    if ( NULL == szStr )
    {
        printf( "The string is null.
" );
        return -1;
    }

    // 分配新节点
    pNew = AllocListNode( szStr );
    if ( NULL == pNew )
    {
        return -1;
    }

    // 将结点插入链表尾部
    if ( pStart != NULL )
    {
        pHead->m_pEnd->m_pNxt = pNew;
        pHead->m_pEnd = pNew;
    }
    else
    {
        pHead->m_pStart = pNew;
        pHead->m_pEnd = pNew;
    }

    return 1;
}

// 摧毁链表
void DestoryList( ListHead **pHead )
{
    ListNode *pStart = (*pHead)->m_pStart,
              *pFree  = NULL;

    if ( NULL == pHead )
        return;

    while ( pStart )
    {
        pFree = pStart;
        pStart= pStart->m_pNxt;
        free( pFree );
        pFree = NULL;
    }

    free( *pHead );
    *pHead = NULL;
}

// 输出链表中信息
void OutputList( ListHead *pHead )
{
    ListNode *pStart = pHead->m_pStart;
    int sum = 0;

    printf( "About statistic:
");
    while ( pStart )
    {
        sum += pStart->m_iCnt;
        printf( "%s:		%d
", pStart->m_szStr, pStart->m_iCnt );
        pStart = pStart->m_pNxt;
    }
    printf( "The total words is %d.
", sum );
    printf( "
" );
}

/* Trie树结构体以及相关操作函数 */
struct TrieNode
{
    int     m_iIsStr;       // 记录此处是否构成一个字符串。
    struct TrieNode *m_pBranch[BranchSize]; // 指向各个子树的指针，小标0-25代表26个字符
    struct ListNode *m_pCountInfo;  // 指向该单词的统计信息结点
};

typedef struct TrieNode TrieNode;

// 分配Trie树的新节点
TrieNode* AllocTrieNode()
{
    TrieNode *pNew = NULL;
    int idx = 0;

    pNew = (TrieNode *) calloc( 1, sizeof( TrieNode ) );
    if ( NULL == pNew )
    {
        printf( "Out of memory.
" );
        return NULL;
    }

    // initialize information.
    for ( ; idx < BranchSize; ++idx )
        pNew->m_pBranch[idx] = NULL;
    pNew->m_pCountInfo  = NULL;
    pNew->m_iIsStr      = 0;

    return pNew;
}

// 在Trie树中查找单词
int SearchNodeInTrie( TrieNode *pRoot,
                      const char *word )
{
    TrieNode *pStart = pRoot;

    while ( *word && pStart )
    {
        pStart = pStart->m_pBranch[*word - 'a'];
        ++word;
    }

    // 在Trie树中找到szStr，则更新结点信息。
    if ( pStart != NULL && pStart->m_iIsStr )
    {
        pStart->m_pCountInfo->m_iCnt++;
        return 1;
    }

    return 0;
}

// 插入单词到Trie树中
int InsertNodeIntoTrie( TrieNode *pRoot,
                        ListHead *pStart,
                        const char *szStr )
{
    TrieNode *location  = pRoot;
    const char *word    = szStr;

    if ( SearchNodeInTrie( pRoot, szStr) == 1 )
        return 0;

    while ( *szStr )
    {
        if ( location->m_pBranch[*szStr - 'a'] == NULL ) // 不存在
        {
            TrieNode *pNew = AllocTrieNode();
            if ( NULL == pNew )
                return -1;
            location->m_pBranch[*szStr - 'a'] = pNew;
        }
        // 每插入一步，相当于一个新串经过，指针要向下移动
        location = location->m_pBranch[*szStr - 'a'];
        ++szStr;
    }
    location->m_iIsStr = 1;
    if ( InsertNodeIntoList( pStart, word ) == 1 )
    {
        location->m_pCountInfo = pStart->m_pEnd;
        return 1;
    }

    return 0;
}

// 摧毁Trie树
void DestoryTrie( TrieNode **pRoot )
{
    TrieNode *TrieStack[NodeMax],
             *pNxt  = NULL,
             *root  = *pRoot;
    int top     = 0,
        idx     = 0;

    // Initialize stack
    for ( ; idx < NodeMax; ++idx )
        TrieStack[idx] = NULL;

    for ( idx = 0; idx < BranchSize; ++idx )
    {
        if ( root->m_pBranch[idx] != NULL )
            TrieStack[top++] = root->m_pBranch[idx];
    }

    // 遍历Trie树，并删除
    while ( top )
    {
        pNxt = TrieStack[--top];

        for ( idx = 0; idx < BranchSize; ++idx )
        {
            if ( pNxt->m_pBranch[idx] != NULL )
                TrieStack[top++] = pNxt->m_pBranch[idx];
        }

        free( pNxt );
        pNxt = NULL;
    }

    free( *pRoot );
    *pRoot = NULL;
}

void TestFunction()
{
    const char *pszStrs[9] =
        {
            "hello", "word", "hi",
            "hello", "hello","hi",
            "word", "word", "word"
        };
    int idx = 0;
    TrieNode *pTrie = NULL;
    ListHead *pList = NULL;

    pTrie = AllocTrieNode();
    if ( NULL == pTrie )
        return;
    pList = AllocListHead();
    if ( NULL == pList )
    {
        DestoryTrie( &pTrie );
        return;
    }

    for ( idx = 0; idx < 9; ++idx )
    {
        InsertNodeIntoTrie( pTrie, pList, pszStrs[idx] );
    }

    OutputList( pList );

    DestoryTrie( &pTrie );
    DestoryList( &pList );
}

int main()
{
    TestFunction();

    return 0;
}

　　Trie树源码参考blog：http://www.cnblogs.com/cherish_yimi/archive/2009/10/12/1581666.html