Pointer comparision issue

I'm having a problem with a pointer and can't get around it..

In a HashTable implementation, I have a list of ordered nodes in each bucket.The problem I have It's in the insert function, in the comparision to see if the next node is greater than the current node(in order to inserted in that position if it is) and keep the order.

You might find this hash implementation strange, but I need to be able to do tons of lookups(but sometimes also very few) and count the number of repetitions if It's already inserted (so I need fasts lookups, thus the Hash , I've thought about self-balanced trees as AVL or R-B trees, but I don't know them so I went with the solution I knew how to implement...are they faster for this type of problem?),but I also need to retrieve them by order when I've finished. Before I had a simple list and I'd retrieve the array, then do a QuickSort, but I think I might be able to improve things by keeping the lists ordered.

What I have to map It's a 27 bit unsigned int(most exactly 3 9 bits numbers, but I convert them to a 27 bit number doing (Sr << 18 | Sg << 9 | Sb) making at the same time their value the hash_value. If you know a good function to map that 27 bit int to an 12-13-14 bit table let me know, I currently just do the typical mod prime solution.

This is my hash_node struct:

class hash_node {
public:
  unsigned int hash_value;    
  int repetitions;
  hash_node *next;                       

  hash_node(  unsigned int hash_val,
                     hash_node *nxt);
 ~hash_node();  
};

And this is the source of the problem

void hash_table::insert(unsigned int hash_value) {

unsigned int p = hash_value % tableSize;
if (table[p]!=0) { //The bucket has some elements already
hash_node *pred; //node to keep the last valid position on the list
    for (hash_node *aux=table[p]; aux!=0; aux=aux->next) {
            pred = aux; //last valid position
        if (aux->hash_value == hash_value ) {
                 //It's already inserted, so we increment it repetition counter
                 aux->repetitions++; 
            } else if (hash_value < (aux->next->hash_value) ) { //The problem
                    //If the next one is greater than the one to insert, we 
                    //create a node in the middle of both.
        aux->next = new hash_node(hash_value,aux->next);
        colisions++;
                    numElem++;
                 }
     }//We have arrive to the end od the list without luck, so we insert it after 
     //the last valid position
 ant->next = new hash_node(hash_value,0);
 colisions++;
     numElem++;
 }else { //bucket it's empty, insert it right away.
    table[p] = new hash_node(hash_value, 0);
    numElem++;
 }

}

T开发者_运维知识库his is what gdb shows:

Program received signal SIGSEGV, Segmentation fault.
0x08050b4b in hash_table::insert (this=0x806a310, hash_value=3163181) at ht.cc:132
 132                    } else if (hash_value < (aux->next->hash_value) ) {

Which effectively indicates I'm comparing a memory adress with a value, right? Hope It was clear. Thanks again!

aux->next->hash_value

There's no check whether "next" is NULL.

aux->next might be NULL at that point? I can't see where you have checked whether aux->next is NULL.