Hash Table Segmentation Fault

[const]

Hello, I am working on a Hash Table program. It compiles, however it gets a segmentation fault. Any idea why? Thanks.

 #include <iostream>
#include <cstddef>
#include <string>
#include <cmath>
#include <ctime>
#include <cstdlib>

using namespace std;

template <typename KEY, typename VALUE>
class Entry
{
	template<typename K, typename V> friend class HashTable;

private:
	KEY key;
	VALUE value;
	Entry * next_entry;

public:
	/*** Constructors ***/
	Entry(void) : key(KEY()), value(VALUE()), next_entry(NULL) {}
	//If you would like you can convert constructors to have this look
	~Entry();
	Entry(KEY key, VALUE value)
	{
		this->template key = key;
		this->template value = value;
		this->template next_entry = NULL;
	}
	Entry(KEY key, VALUE value, Entry * next) : key(key), value(value), next_entry(next) {}

	//accessors
	KEY get_key() { return key; }
	VALUE get_value() { return value; }
	Entry * get_next_entry() { return next_entry; }

	//mutators
	void set_key(KEY key) { this->key = key; }
	void set_value(VALUE value) { this->value = value; }
	void set_next_entry(Entry * entry) { this->next_entry = entry; }
	// is this the thing that should change?
};


template<typename K, typename V>
class HashTable
{
private:
	int N;
	int count;
public:
	
	Entry<K, V> **hash_table;
	HashTable()
	{
		this->N = 10000;
		hash_table = new Entry<K, V> *[this->N];

		for (int i = 0; i < this->N; i++)
			hash_table[i] = NULL;
	}

	HashTable(int N)
	{
		this->N = N;
		hash_table = new Entry<K, V> *[this->N];

		for (int i = 0; i < this->N; i++)
		{
			hash_table[i] = NULL;
		}
	}
	~HashTable()
	{
		
		delete [] hash_table;
		
	}
	
	


	void resize(bool grow)
	{

		int buckets = this->N;
		Entry<K, V> ** old = this->hash_table;
		Entry<K, V> * swap;
	

		hash_table = new Entry<K, V> *[count];
		for (int i = 0; i < count; i++)
		{
			hash_table[i] = NULL;
		}


		for (int i = 0; i < buckets; i++)
		{
			while (old[i] != NULL)
			{
				swap = old[i];
				old[i] = swap->get_next_entry();
				insert(swap);
			}
		}
		delete[] old;

	}


	int hashcode(string s)
	{
		int hash_value = 0;
		for (int i = 0; i < s.length(); i++)
		{
			hash_value = (127 * hash_value + (unsigned char)s[i]) % 16908799;
		}
		return hash_value;
	}

	int hashcode(int i)
	{
		int hash_value = (127 * i) % 16908799;
		return hash_value;
	}


	int hashcode(char c)
	{
		int hash_value = static_cast<int>(c);
		hash_value = (127 * hash_value) % 16908799;
		return hash_value;
	}


	int hashcode(unsigned long ul)
	{
		int hash_code;

		if (ul <= 2147483647)
		{
			hash_code = static_cast<int>(ul);
		}
		else
		{
			ul = ul / 2;
			hash_code = static_cast<int>(ul);
			hashcode = 0 - hash_code;
		}

		return hash_code;

	}


	int compression(int hc)
	{
		int compress = ((5 * hc + 6) % this->N);
		return compress;
	}


	Entry<K, V> * find(Entry<K, V> * e)
	{
		int hc;
		V value = e->get_value();
		hc = hashcode(value);
		hc = compression(hc);
		Entry<K, V> * box = hash_table[hc];
		return box;

	}

	void replace(Entry<K, V> * e1, Entry<K, V> * e2)
	{
		e2->set_key(e1->get_key());
		e2->set_value(e1->get_value());
		delete e1;
	}

	void remove(Entry<K, V> * e)
	{
		int hc;
		V value = e->get_value();
		hc = hashcode(value);
		hc = compression(hc);
		Entry<K, V> * track = hash_table[hc];
		Entry<K, V> * temp = hash_table[hc];
		while (e != track)
		{
			if (track != NULL)
			{
				temp = track;
				track = track->get_next_entry();
			}
			else
			{
				return; // this doesnt tell the user there wasnt anything deleted, but it shouldnt need to.
			}
		}

		temp->set_next(track->get_next_entry());
		delete track;
		count--;

	}
	void insert(Entry<K, V> * e)
	{
		int hc;
		V value = e->get_value();
		hc = hashcode(value);
		hc = compression(hc);


		if (hash_table[hc] == NULL)
		{
			hash_table[hc] = e;
		}

		else
		{
			Entry<K, V> * swap;
			swap = hash_table[hc];
			e->set_next_entry(swap);
			hash_table[hc] = e;
		}

		count++;

	}

	/* if grow = 1 increase the table
	* otherwise decrease the table
	*/






	double compute_load_factor()
	{
		int load = this->count / this->N;
		// 0.8 - 1.2     n/N  where n = number of entries and N = number of buckets
		return load;
	}

	int longest_chain_length()
	{
		int count = 0;
		int highest = 0;
		Entry<K, V> * track;
		for (int i = 0; i < this->N; i++)
		{
			track = this->hash_table[i];
			if (track != NULL)
			{
				count++;
			}
			while (track->get_next_entry() != NULL)
			{
				count++;
				track = track->get_next_entry();
			}
			if (count > highest)
			{
				highest = count;
			}
			count = 0;

		}
		return highest;
	}
};



int main()
{
	//seed the random number generator
	srand(42);

	HashTable<unsigned long, string>  table_01(10); //Should be 10k
	unsigned long key;
	string value;
	Entry<unsigned long, string> * e;

	// Fill the table with random entries
	for (int i = 0; i < 20; i++)
	{
		/* create a random entry */
		key = (sizeof(int) < sizeof(long)) ? (static_cast<int>(((unsigned long)rand()) << (sizeof(int) * 8)) | rand()) : rand(); // what
		value = "";
		for (int j = 0; j < (rand() % 45 + 1); j++)
		{
			value += 'a' + rand() % 26;
			e = new Entry<unsigned long, string>(key, value);

		}
		table_01.insert(e);
	}
	cout << "Longest Chain: " << table_01.longest_chain_length() << endl;
	cout << "Load Factor: " << table_01.compute_load_factor() << endl;

	table_01.resize(true);
	cout << "Longest Chain: " << table_01.longest_chain_length() << endl;
	cout << "Load Factor: " << table_01.compute_load_factor() << endl;

	return 0;
}

[const]

Nevermind I fixed it. Problem was with my table initialization in main being different than my table entries. Solved.