通过trie树单词自动补全（二）

经常使用iciba进行单词查询， 关于他的搜索建议是通过单词前缀做的索引， 所以自己想动手实现下， 当然如果借助mysql的话，一条sql语句就能实现， 网上查询了下trie正适合做这个，所以通过C语言自己做了个demo

sug.c

/* 
 * 单词自动补全功能
 * File:   search.c
 * Author: baijianmin
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>
#include <time.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAX_CHILD 26
#define LISTEN_PORT 8080
#define LOG_DEBUG_PATH "./logs/debug.log"
#define LOG_ERROR_PATH "./logs/error.log"
#define DATA_PATH "one.txt"

/**
 * define log level
 */
enum log_level {
    DEBUG = 0,
    ERROR = 1
};

#define error(...) 
        logger(ERROR, __LINE__, __VA_ARGS__)

#define debug(...) 
        logger(DEBUG, __LINE__, __VA_ARGS__)

#define assert(expr, rc) 
        if(!(expr)){    
                error(#expr"is null or 0");     
                return rc;      
        }

/**
 * trie node
 */
typedef struct node_s {
    int count;
    struct node_s *child[MAX_CHILD];
    char words[20];
} node_t;

/**
 * global var
 */
node_t *global_root;


/**
 * get now timestr
 */
static void get_time(char *time_str, size_t len) {
    time_t tt;
    struct tm local_time;
    time(&tt);
    localtime_r(&tt, &local_time);
    strftime(time_str, len, "%m-%d %H:%M:%S", &local_time);
}

/**
 * log
 */
static void logger(int flag, int line, const char *fmt, ...) {
    FILE *fp = NULL;
    char time_str[20 + 1];
    va_list args;
    get_time(time_str, sizeof(time_str));

    switch (flag) {
        case DEBUG:
            fp = fopen(LOG_DEBUG_PATH, "a");
            if (!fp) {
                return;
            }
            fprintf(fp, "%s DEBUG (%d:%d) ", time_str, getpid(), line);
            break;
        case ERROR:
            fp = fopen(LOG_ERROR_PATH, "a");
            if (!fp) {
                return;
            }
            fprintf(fp, "%s ERROR (%d:%d) ", time_str, getpid(), line);
            break;
        default:
            return;
    }

    va_start(args, fmt);
    vfprintf(fp, fmt, args);
    va_end(args);
    fprintf(fp, "
");

    fclose(fp);
    return;
}

/**
 * listen fro connections on a specified port
 */
int startup() {
    int sockfd = -1;
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof (addr));
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        error("socket fail: %s", strerror(errno));
        return -1;
    }
    addr.sin_family = AF_INET;
    addr.sin_port = htons(LISTEN_PORT);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(sockfd, (struct sockaddr *) &addr, sizeof (addr))) {
        error("bind fail: %s", strerror(errno));
        return -1;
    }
    if (listen(sockfd, 5)) {
        error("listen fail: %s", strerror(errno));
        return -1;
    }
    return sockfd;
}

/**
 * create node
 */
node_t *createNode() {
    node_t *node = (node_t *) calloc(1, sizeof (node_t));
    if (node == NULL) {
        error("createNode fail: %s", strerror(errno));
    }
}

/**
 * insert words 
 */
int insert(node_t *root, char *words) {
    if (!root || words[0] == '') {
        error("insert fail, root or words is null");
        return -1;
    }
    node_t *node = root;
    node_t *tmp;
    char *s = words;
    while (*s != '') {
        if (node->child[*s - 'a'] == NULL) {
            tmp = createNode();
            if (tmp == NULL) {
                goto err;
            }
            node->child[*s - 'a'] = tmp;
        }
        node = node->child[*s - 'a'];
        s++;
    }
    node->count++;
    memcpy(node->words, words, strlen(words));
    return 0;
err:
    return -1;
}

void search_child(node_t *node, int client_sock) {
    if (!node) {
        error("search_child fail, node is null");
        return;
    }
    int i;
    if (node->count) {
        send(client_sock, node->words, strlen(node->words), 0);
                send(client_sock, "|", 1, 0);
    }
    for (i = 0; i < MAX_CHILD; i++) {
        if (node->child[i]) {
            search_child(node->child[i], client_sock);
        }
    }
}

/**
 * search
 */
int search(node_t *root, char *words, int client_sockfd) {
    //--------------------------------fixme-------------------------------------
    char *ps = words;
    while (*ps != '') {
        if (*ps < 'a' || *ps > 'z') {
            *ps = '';
            break;
        }
        ps++;
    }
    //--------------------------------------------------------------------------
    if (!root || words[0] == '') {
        error("search fail, root or words is null");
        return -1;
    }
        debug("request query: %s", words);
    char *s = words;
    node_t *node = root;
    while (*s != '') {
        if (node->child[*s - 'a'] == NULL) {
            break;
        }
        node = node->child[*s - 'a'];
        s++;
    }
    if (*s == '') {
#if 0        
        if (node->count == 0) {
            printf("没有搜索到这个字符串，但是它是某个字符串的前缀
");
        } else {
            printf("搜索到此字符串,出现次数为:%d
", node->count);
        }
#endif
        search_child(node, client_sockfd);
        
    } else {
#if 0        
        printf("没有搜索到这个字符串:%s, %d
", words, strlen(words));
#endif
    }
    close(client_sockfd);
}

/**
 * free mem
 */
void del(node_t *root) {
    if (!root) {
        error("del fail, root is null");
        return;
    }

    int i;
    for (i = 0; i < MAX_CHILD; i++) {
        if (root->child[i]) {
            del(root->child[i]);
        }
    }
    free(root);

}

/**
 * load data from file
 */
int load_data() {
        global_root = createNode();
        if(!global_root){
                return -1;
        }
    FILE *fp = fopen(DATA_PATH, "r");
    if (!fp) {
        error("open fail fail: %S", strerror(errno));
        return -1;
    }
    char words[20];
    while (!feof(fp) && fgets(words, sizeof (words), fp)) {
        words[strlen(words) - 1] = '';
        insert(global_root, words);
        memset(words, 0, sizeof (words));
    }
    debug("load_data success");
    return 0;
}

/**
 * response the request
 */
void accept_request(int client_sockfd){
    char buf[20];
    memset(buf, 0, sizeof(buf));
    recv(client_sockfd, buf, sizeof(buf), 0);
    search(global_root, buf, client_sockfd);
    //close client connection
    close(client_sockfd);
}

int main(void) {
    int server_sockfd = -1, client_sockfd = -1;
    struct sockaddr_in client_addr;
    memset(&client_addr, 0, sizeof (client_sockfd));
    int addr_len = sizeof (client_sockfd);

    server_sockfd = startup();
    if (server_sockfd < 0) {
        return -1;
    }

    //load data from file
    load_data();

    //waitting for client
    while (1) {
        client_sockfd = accept(server_sockfd,
                (struct sockaddr *) &client_addr, &addr_len);
        if(client_sockfd < 0){
            error("accept fail, %s", strerror(errno));
            return -1;
        }
        accept_request(client_sockfd);
    }
    
    close(server_sockfd);
    return 0;
}

sug.php

<?php

if($_GET['query']){
        $query = $_GET['query'];
}else{
        exit(json_encode(array()));
}

$host = "127.0.0.1";
$port = "8080";

$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP) or die("Unable to create socket
");
@socket_connect($socket, $host, $port) or die("Connect error.
");

if ($err = socket_last_error($socket)){

        socket_close($socket);
        die(socket_strerror($err) . "
");
}

$len = socket_write ($socket , $query, strlen($query));
$querys = "";
$ret = socket_read($socket, 100);
while($ret){
        $querys.=$ret;
        $ret = socket_read($socket, 100);
}
socket_close($socket);

$querysArr = explode("|", $querys);
array_pop($querysArr);

echo json_encode($querysArr);

效果：

http://www.idoushuo.com/sug.php?query=a