哈希树简单实现

#include <stdio.h>
#include <malloc.h>

typedef struct __hash_tree {
    int level;
    int value;
    int* primes; // "2 3 5 0" 0 is a end number
    char count;
    struct __hash_tree** nodes;
    struct __hash_tree* root;
} HashTree;

HashTree* new_hash_tree(int level,HashTree* root){
    printf("new hash tree,level=%d\n",level);
    HashTree* p = (HashTree*)malloc(sizeof(HashTree));
    if (p == NULL){
        return NULL;
    }
    p->level = level;
    p->nodes = (HashTree**)malloc(sizeof(HashTree*) * level);
    if(p->nodes == NULL){
        free(p);
        return NULL;
    }
    int i = 0;
    for(;i<level;i++)
        p->nodes[i]= NULL;

    return p;
}

void free_hash_tree(HashTree* n){
    int i = 0;
    for(;i<n->level-1;i++){
        if(n->nodes[i] != NULL)
           free_hash_tree(n->nodes[i]);
    }
    free(n->nodes);
    free(n);
}

HashTree* newroot_hash_tree(int* primes){
    HashTree* p = new_hash_tree(primes[0],NULL);
    if(p == NULL)
        return p;
    p->primes = primes;
    p->root = p;
    return p;
}

//parameter "primes" should be NULL or should be the same value with function "newroot_hash_tree" parameter
void hash_tree_insert(HashTree* node,int n,int value,int* primes){
    if(primes == NULL)
        primes = node->root->primes;
    int index = n % (node->level);
    primes++;
    printf("## n[%d] level[%d] index[%d] prime[%d] \n",n,node->level, n % (node->level),*primes);
    if(node->nodes[index] == NULL){
        node->nodes[index] = new_hash_tree(*primes,node->root);
    }
    if(*primes == 0){
        node->nodes[index]->value = value;
        node->nodes[index]->count = 1;
        return ;
    }else{
        hash_tree_insert(node->nodes[index],n,value,primes);
    }
}

int hash_tree_find(HashTree* node,int n){
    if(node->level == 0 && node->count == 1){
        return node->value;
    }
    int index = n % (node->level);
    printf("** n[%d] level[%d] index[%d] %x\n",n,node->level, n % (node->level),node->nodes[index]);
    if(node->nodes[index] == NULL){
        return -1;
    }
    return hash_tree_find(node->nodes[index],n);
}

int getNextPrimeNumber(int prev){  //previous number
    prev++;
    int i = 2;
    int p = 1;
    for(;i<prev-1;i++){
        if(prev%i == 0){
            p = 0;
            break;
        }
    }
    if(p == 1)
        return prev;
    return getNextPrimeNumber(prev);
}

int main(void)
{
    int n = 2;
    int* primes = (int*)malloc(sizeof(int) * (n+1));
    primes[0] = 2;
    int i;
    for(i=1;i<n;i++){
        primes[i] = getNextPrimeNumber(primes[i-1]);
    }
    primes[n] = 0;
    for(i=0;i<n+1;i++){
        printf("%d,",primes[i]);
    }
    printf("\n");
    int max = 1;
    for(i=0;i<n;i++){
        max *= primes[i];
    }
    printf("max:%d\n",max);
    HashTree* root = newroot_hash_tree(primes);

    for(i=0;i<max;i++){
         hash_tree_insert(root,i,i*2,NULL);
    }
    printf("#########################################################\n");
    printf("#########################################################\n");
    int value = 0;
    for(i=0;i<max+2;i++){
        value = hash_tree_find(root,i);
        if(value == -1){
            printf("not found:%d\n",i);
            continue;
        }
        if(value != i*2){
            printf("wrong result:i:%d value:%d\n",i,value);
            continue ;
        }
        printf("%d %d\n",i,value);
    }

    return 0;
}
 

转载于:https://my.oschina.net/u/3025685/blog/810880